projects / fw / sdcc / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Improved the Register Banking algorithm.
[fw/sdcc] / src / pic / genarith.c
diff --git a/src/pic/genarith.c b/src/pic/genarith.c
index 644311fd4b452acc47cc3498911f178b9183d157..8b4aa9646260532df65ed693de1a09ff6097bc7a 100644 (file)
--- a/src/pic/genarith.c
+++ b/src/pic/genarith.c
@@ -63,6 +63,10 @@
 #include "pcode.h"
 #include "gen.h"
 
+
+#define BYTEofLONG(l,b) ( (l>> (b<<3)) & 0xff)
+void DEBUGpic14_AopType(int line_no, operand *left, operand *right, operand *result);
+
 const char *AopType(short type)
 {
   switch(type) {
@@ -102,6 +106,9 @@ const char *AopType(short type)
   case AOP_ACC:
     return "AOP_ACC";
     break;
+  case AOP_PCODE:
+    return "AOP_PCODE";
+    break;
   }
 
   return "BAD TYPE";
@@ -115,10 +122,10 @@ bool genPlusIncr (iCode *ic)
     unsigned int size = pic14_getDataSize(IC_RESULT(ic));
 
     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-    DEBUGpic14_emitcode ("; ","result %d, left %d, right %d",
-                  AOP_TYPE(IC_RESULT(ic)),
-                  AOP_TYPE(IC_LEFT(ic)),
-                  AOP_TYPE(IC_RIGHT(ic)));
+    DEBUGpic14_emitcode ("; ","result %s, left %s, right %s",
+                        AopType(AOP_TYPE(IC_RESULT(ic))),
+                        AopType(AOP_TYPE(IC_LEFT(ic))),
+                        AopType(AOP_TYPE(IC_RIGHT(ic))));
 
     /* will try to generate an increment */
     /* if the right side is not a literal 
@@ -138,12 +145,12 @@ bool genPlusIncr (iCode *ic)
 
       int offset = MSB16;
 
-      emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
+      emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),LSB));
       //pic14_emitcode("incf","%s,f",aopGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
 
       while(--size) {
        emitSKPNZ;
-       emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),offset++,FALSE,FALSE));
+       emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),offset++));
        //pic14_emitcode(" incf","%s,f",aopGet(AOP(IC_RESULT(ic)),offset++,FALSE,FALSE));
       }
 
@@ -155,7 +162,7 @@ bool genPlusIncr (iCode *ic)
     if( strcmp(aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE),"a")  &&
        (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) ) {
       
-      emitpcode(POC_BCF, popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+      emitpcode(POC_BCF, popGet(AOP(IC_RESULT(ic)),0));
       pic14_emitcode("bcf","(%s >> 3), (%s & 7)",
               AOP(IC_RESULT(ic))->aopu.aop_dir,
               AOP(IC_RESULT(ic))->aopu.aop_dir);
@@ -167,7 +174,7 @@ bool genPlusIncr (iCode *ic)
       //pic14_emitcode("andlw","1");
 
       emitSKPZ;
-      emitpcode(POC_BSF, popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+      emitpcode(POC_BSF, popGet(AOP(IC_RESULT(ic)),0));
       pic14_emitcode("bsf","(%s >> 3), (%s & 7)",
               AOP(IC_RESULT(ic))->aopu.aop_dir,
               AOP(IC_RESULT(ic))->aopu.aop_dir);
@@ -187,15 +194,14 @@ bool genPlusIncr (iCode *ic)
     if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
        
       while (icount--) 
-       emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+       emitpcode(POC_INCF, popGet(AOP(IC_RESULT(ic)),0));
       //pic14_emitcode("incf","%s,f",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
        
       return TRUE ;
     }
     
-    DEBUGpic14_emitcode ("; ","couldn't increment result-%s  left-%s",
-                  aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE),
-                  aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+    DEBUGpic14_emitcode ("; ","couldn't increment ");
+
     return FALSE ;
 }
 
@@ -225,61 +231,73 @@ void pic14_outBitAcc(operand *result)
 void genPlusBits (iCode *ic)
 {
 
-    DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-    /*
-      The following block of code will add two bits. 
-      Note that it'll even work if the destination is
-      the carry (C in the status register).
-      It won't work if the 'Z' bit is a source or destination.
-    */
+  DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
 
-    /* If the result is stored in the accumulator (w) */
-    //if(strcmp(aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE),"a") == 0 ) {
-    if(AOP_TYPE(IC_RESULT(ic)) != AOP_ACC) {
-      //emitpcode(  ( ((int) operandLitValue(right)) ? POC_BSF : POC_BCF),
-      //             popGet(AOP(result),0,FALSE,FALSE));
-
-      emitpcode(POC_MOVLW, popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
-      emitpcode(POC_BCF,   popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
-      emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
-      emitpcode(POC_XORWF, popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
-      emitpcode(POC_BTFSC, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
-      emitpcode(POC_XORWF, popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
-
-       pic14_emitcode("movlw","(1 << (%s & 7))",
-                AOP(IC_RESULT(ic))->aopu.aop_dir,
-                AOP(IC_RESULT(ic))->aopu.aop_dir);
-       pic14_emitcode("bcf","(%s >> 3), (%s & 7)",
-                AOP(IC_RESULT(ic))->aopu.aop_dir,
-                AOP(IC_RESULT(ic))->aopu.aop_dir);
-       pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
-                AOP(IC_RIGHT(ic))->aopu.aop_dir,
-                AOP(IC_RIGHT(ic))->aopu.aop_dir);
-       pic14_emitcode("xorwf","(%s >>3),f",
-                AOP(IC_RESULT(ic))->aopu.aop_dir);
-       pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
-                AOP(IC_LEFT(ic))->aopu.aop_dir,
-                AOP(IC_LEFT(ic))->aopu.aop_dir);
-       pic14_emitcode("xorwf","(%s>>3),f",
-                AOP(IC_RESULT(ic))->aopu.aop_dir);
-    } else { 
-
-      emitpcode(POC_CLRW, NULL);
-      emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
-      emitpcode(POC_XORLW, popGetLit(1));
-      emitpcode(POC_BTFSC, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
-      emitpcode(POC_XORLW, popGetLit(1));
-
-      pic14_emitcode("clrw","");
-      pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
-                AOP(IC_RIGHT(ic))->aopu.aop_dir,
-                AOP(IC_RIGHT(ic))->aopu.aop_dir);
-      pic14_emitcode("xorlw","1");
-      pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
-              AOP(IC_LEFT(ic))->aopu.aop_dir,
-              AOP(IC_LEFT(ic))->aopu.aop_dir);
-      pic14_emitcode("xorlw","1");
-    }
+  DEBUGpic14_emitcode ("; ","result %s, left %s, right %s",
+                      AopType(AOP_TYPE(IC_RESULT(ic))),
+                      AopType(AOP_TYPE(IC_LEFT(ic))),
+                      AopType(AOP_TYPE(IC_RIGHT(ic))));
+  /*
+    The following block of code will add two bits. 
+    Note that it'll even work if the destination is
+    the carry (C in the status register).
+    It won't work if the 'Z' bit is a source or destination.
+  */
+
+  /* If the result is stored in the accumulator (w) */
+  //if(strcmp(aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE),"a") == 0 ) {
+  switch(AOP_TYPE(IC_RESULT(ic))) {
+  case AOP_ACC:
+    emitpcode(POC_CLRW, NULL);
+    emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0));
+    emitpcode(POC_XORLW, popGetLit(1));
+    emitpcode(POC_BTFSC, popGet(AOP(IC_LEFT(ic)),0));
+    emitpcode(POC_XORLW, popGetLit(1));
+
+    pic14_emitcode("clrw","");
+    pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
+                  AOP(IC_RIGHT(ic))->aopu.aop_dir,
+                  AOP(IC_RIGHT(ic))->aopu.aop_dir);
+    pic14_emitcode("xorlw","1");
+    pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
+                  AOP(IC_LEFT(ic))->aopu.aop_dir,
+                  AOP(IC_LEFT(ic))->aopu.aop_dir);
+    pic14_emitcode("xorlw","1");
+    break;
+  case AOP_REG:
+    emitpcode(POC_MOVLW, popGetLit(0));
+    emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0));
+    emitpcode(POC_XORLW, popGetLit(1));
+    emitpcode(POC_BTFSC, popGet(AOP(IC_LEFT(ic)),0));
+    emitpcode(POC_XORLW, popGetLit(1));
+    emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),0));
+    break;
+  default:
+    emitpcode(POC_MOVLW, popGet(AOP(IC_RESULT(ic)),0));
+    emitpcode(POC_BCF,   popGet(AOP(IC_RESULT(ic)),0));
+    emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0));
+    emitpcode(POC_XORWF, popGet(AOP(IC_RESULT(ic)),0));
+    emitpcode(POC_BTFSC, popGet(AOP(IC_LEFT(ic)),0));
+    emitpcode(POC_XORWF, popGet(AOP(IC_RESULT(ic)),0));
+
+    pic14_emitcode("movlw","(1 << (%s & 7))",
+                  AOP(IC_RESULT(ic))->aopu.aop_dir,
+                  AOP(IC_RESULT(ic))->aopu.aop_dir);
+    pic14_emitcode("bcf","(%s >> 3), (%s & 7)",
+                  AOP(IC_RESULT(ic))->aopu.aop_dir,
+                  AOP(IC_RESULT(ic))->aopu.aop_dir);
+    pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
+                  AOP(IC_RIGHT(ic))->aopu.aop_dir,
+                  AOP(IC_RIGHT(ic))->aopu.aop_dir);
+    pic14_emitcode("xorwf","(%s >>3),f",
+                  AOP(IC_RESULT(ic))->aopu.aop_dir);
+    pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
+                  AOP(IC_LEFT(ic))->aopu.aop_dir,
+                  AOP(IC_LEFT(ic))->aopu.aop_dir);
+    pic14_emitcode("xorwf","(%s>>3),f",
+                  AOP(IC_RESULT(ic))->aopu.aop_dir);
+    break;
+  }
 
 }
 
@@ -362,27 +380,48 @@ static void genAddLit2byte (operand *result, int offr, int lit)
   case 0:
     break;
   case 1:
-    emitpcode(POC_INCF, popGet(AOP(result),offr,FALSE,FALSE));
+    emitpcode(POC_INCF, popGet(AOP(result),offr));
     break;
   case 0xff:
-    emitpcode(POC_DECF, popGet(AOP(result),offr,FALSE,FALSE));
+    emitpcode(POC_DECF, popGet(AOP(result),offr));
     break;
   default:
     emitpcode(POC_MOVLW,popGetLit(lit&0xff));
-    emitpcode(POC_ADDWF,popGet(AOP(result),offr,FALSE,FALSE));
+    emitpcode(POC_ADDWF,popGet(AOP(result),offr));
   }
 
 }
 
-static void genAddLit (operand *result,operand *left, int lit)
+static void emitMOVWF(operand *reg, int offset)
+{
+  if(!reg)
+    return;
+
+  if (AOP_TYPE(reg) == AOP_ACC) {
+    DEBUGpic14_emitcode ("; ***","%s  %d ignoring mov into W",__FUNCTION__,__LINE__);
+    return;
+  }
+
+  emitpcode(POC_MOVWF, popGet(AOP(reg),offset));
+
+}
+
+static void genAddLit (iCode *ic, int lit)
 {
 
   int size,same;
+  int lo;
+
+  operand *result;
+  operand *left;
 
   DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-  size = pic14_getDataSize(result);
 
-  same = ((left == result) || (AOP(left) == AOP(result)));
+
+  left = IC_LEFT(ic);
+  result = IC_RESULT(ic);
+  same = pic14_sameRegs(AOP(left), AOP(result));
+  size = pic14_getDataSize(result);
 
   if(same) {
 
@@ -392,7 +431,7 @@ static void genAddLit (operand *result,operand *left, int lit)
      
     else if(size == 2) {
       int hi = 0xff & (lit >> 8);
-      int lo = lit & 0xff;
+      lo = lit & 0xff;
 
       switch(hi) {
       case 0: 
@@ -403,21 +442,21 @@ static void genAddLit (operand *result,operand *left, int lit)
        case 0:
          break;
        case 1:
-         emitpcode(POC_INCF, popGet(AOP(result),0,FALSE,FALSE));
+         emitpcode(POC_INCF, popGet(AOP(result),0));
          emitSKPNZ;
-         emitpcode(POC_INCF, popGet(AOP(result),MSB16,FALSE,FALSE));   
+         emitpcode(POC_INCF, popGet(AOP(result),MSB16));
          break;
        case 0xff:
-         emitpcode(POC_DECF, popGet(AOP(result),0,FALSE,FALSE));
-         emitpcode(POC_INCFSZW, popGet(AOP(result),0,FALSE,FALSE));
-         emitpcode(POC_INCF, popGet(AOP(result),MSB16,FALSE,FALSE));   
+         emitpcode(POC_DECF, popGet(AOP(result),0));
+         emitpcode(POC_INCFSZW, popGet(AOP(result),0));
+         emitpcode(POC_INCF, popGet(AOP(result),MSB16));
 
          break;
        default:
          emitpcode(POC_MOVLW,popGetLit(lit&0xff));
-         emitpcode(POC_ADDWF,popGet(AOP(result),0,FALSE,FALSE));
+         emitpcode(POC_ADDWF,popGet(AOP(result),0));
          emitSKPNC;
-         emitpcode(POC_INCF, popGet(AOP(result),MSB16,FALSE,FALSE));   
+         emitpcode(POC_INCF, popGet(AOP(result),MSB16));
 
 
        }
@@ -428,19 +467,19 @@ static void genAddLit (operand *result,operand *left, int lit)
        DEBUGpic14_emitcode ("; hi = 1","%s  %d",__FUNCTION__,__LINE__);
        switch(lo) {
        case 0:  /* 0x0100 */
-         emitpcode(POC_INCF, popGet(AOP(result),MSB16,FALSE,FALSE));   
+         emitpcode(POC_INCF, popGet(AOP(result),MSB16));
          break;
        case 1:  /* 0x0101  */
-         emitpcode(POC_INCF, popGet(AOP(result),MSB16,FALSE,FALSE));
-         emitpcode(POC_INCF, popGet(AOP(result),0,FALSE,FALSE));
+         emitpcode(POC_INCF, popGet(AOP(result),MSB16));
+         emitpcode(POC_INCF, popGet(AOP(result),0));
          emitSKPNZ;
-         emitpcode(POC_INCF, popGet(AOP(result),MSB16,FALSE,FALSE));   
+         emitpcode(POC_INCF, popGet(AOP(result),MSB16));
          break;
        case 0xff: /* 0x01ff */
-         emitpcode(POC_DECF, popGet(AOP(result),0,FALSE,FALSE));
-         emitpcode(POC_INCFSZW, popGet(AOP(result),0,FALSE,FALSE));
-         emitpcode(POC_INCF, popGet(AOP(result),MSB16,FALSE,FALSE));   
-         emitpcode(POC_INCF, popGet(AOP(result),MSB16,FALSE,FALSE));   
+         emitpcode(POC_DECF, popGet(AOP(result),0));
+         emitpcode(POC_INCFSZW, popGet(AOP(result),0));
+         emitpcode(POC_INCF, popGet(AOP(result),MSB16));
+         emitpcode(POC_INCF, popGet(AOP(result),MSB16));
        }         
        break;
 
@@ -449,11 +488,11 @@ static void genAddLit (operand *result,operand *left, int lit)
        /* lit = 0xffLL */
        switch(lo) {
        case 0:  /* 0xff00 */
-         emitpcode(POC_DECF, popGet(AOP(result),MSB16,FALSE,FALSE));
+         emitpcode(POC_DECF, popGet(AOP(result),MSB16));
          break;
        case 1:  /*0xff01 */
-         emitpcode(POC_INCFSZ, popGet(AOP(result),0,FALSE,FALSE));
-         emitpcode(POC_DECF, popGet(AOP(result),MSB16,FALSE,FALSE));
+         emitpcode(POC_INCFSZ, popGet(AOP(result),0));
+         emitpcode(POC_DECF, popGet(AOP(result),MSB16));
          break;
 /*     case 0xff: * 0xffff *
          emitpcode(POC_INCFSZW, popGet(AOP(result),0,FALSE,FALSE));
@@ -463,9 +502,9 @@ static void genAddLit (operand *result,operand *left, int lit)
 */
        default:
          emitpcode(POC_MOVLW,popGetLit(lo));
-         emitpcode(POC_ADDWF,popGet(AOP(result),0,FALSE,FALSE));
+         emitpcode(POC_ADDWF,popGet(AOP(result),0));
          emitSKPC;
-         emitpcode(POC_DECF, popGet(AOP(result),MSB16,FALSE,FALSE));
+         emitpcode(POC_DECF, popGet(AOP(result),MSB16));
          
        }
 
@@ -481,9 +520,9 @@ static void genAddLit (operand *result,operand *left, int lit)
          break;
        case 1:  /* 0xHH01 */
          emitpcode(POC_MOVLW,popGetLit((hi+1)&0xff));
-         emitpcode(POC_INCFSZ, popGet(AOP(result),0,FALSE,FALSE));
+         emitpcode(POC_INCFSZ, popGet(AOP(result),0));
          emitpcode(POC_MOVLW,popGetLit(hi));
-         emitpcode(POC_ADDWF,popGet(AOP(result),MSB16,FALSE,FALSE));
+         emitpcode(POC_ADDWF,popGet(AOP(result),MSB16));
          break;
 /*     case 0xff: * 0xHHff *
          emitpcode(POC_MOVFW, popGet(AOP(result),0,FALSE,FALSE));
@@ -493,15 +532,111 @@ static void genAddLit (operand *result,operand *left, int lit)
          break;
 */     default:  /* 0xHHLL */
          emitpcode(POC_MOVLW,popGetLit(lo));
-         emitpcode(POC_ADDWF, popGet(AOP(result),0,FALSE,FALSE));
+         emitpcode(POC_ADDWF, popGet(AOP(result),0));
          emitpcode(POC_MOVLW,popGetLit(hi));
          emitSKPNC;
          emitpcode(POC_MOVLW,popGetLit((hi+1) & 0xff));
-         emitpcode(POC_ADDWF,popGet(AOP(result),MSB16,FALSE,FALSE));
+         emitpcode(POC_ADDWF,popGet(AOP(result),MSB16));
          break;
        }
 
       }
+    } else {
+      int carry_info = 0;
+      int offset = 0;
+      /* size > 2 */
+      DEBUGpic14_emitcode (";  add lit to long","%s  %d",__FUNCTION__,__LINE__);
+
+      while(size--) {
+       lo = BYTEofLONG(lit,0);
+
+       if(carry_info) {
+         switch(lo) {
+         case 0:
+           switch(carry_info) {
+           case 1:
+             emitSKPNZ;
+             emitpcode(POC_INCF, popGet(AOP(result),offset));
+             break;
+           case 2:
+             emitpcode(POC_RLFW, popGet(AOP(result),offset));
+             emitpcode(POC_ANDLW,popGetLit(1));
+             emitpcode(POC_ADDWF, popGet(AOP(result),offset));
+             break;
+           default: /* carry_info = 3  */
+             emitSKPNC;
+             emitpcode(POC_INCF, popGet(AOP(result),offset));
+             carry_info = 1;
+             break;
+           }
+           break;
+         case 0xff:
+           emitpcode(POC_MOVLW,popGetLit(lo));
+           if(carry_info==1) 
+             emitSKPZ;
+           else
+             emitSKPC;
+           emitpcode(POC_ADDWF, popGet(AOP(result),offset));
+           break;
+         default:
+           emitpcode(POC_MOVLW,popGetLit(lo));
+           if(carry_info==1) 
+             emitSKPNZ;
+           else
+             emitSKPNC;
+           emitpcode(POC_MOVLW,popGetLit(lo+1));
+           emitpcode(POC_ADDWF, popGet(AOP(result),offset));
+           carry_info=2;
+           break;
+         }
+       }else {
+         /* no carry info from previous step */
+         /* this means this is the first time to add */
+         switch(lo) {
+         case 0:
+           break;
+         case 1:
+           emitpcode(POC_INCF, popGet(AOP(result),offset));
+           carry_info=1;
+           break;
+         default:
+           emitpcode(POC_MOVLW,popGetLit(lo));
+           emitpcode(POC_ADDWF, popGet(AOP(result),offset));
+           if(lit <0x100) 
+             carry_info = 3;  /* Were adding only one byte and propogating the carry */
+           else
+             carry_info = 2;
+           break;
+         }
+       }
+       offset++;
+       lit >>= 8;
+      }
+    
+/*
+      lo = BYTEofLONG(lit,0);
+
+      if(lit < 0x100) {
+       if(lo) {
+         if(lo == 1) {
+           emitpcode(POC_INCF, popGet(AOP(result),0,FALSE,FALSE));
+           emitSKPNZ;
+         } else {
+           emitpcode(POC_MOVLW,popGetLit(lo));
+           emitpcode(POC_ADDWF, popGet(AOP(result),0,FALSE,FALSE));
+           emitSKPNC;
+         }
+         emitpcode(POC_INCF, popGet(AOP(result),1,FALSE,FALSE));
+         emitSKPNZ;
+         emitpcode(POC_INCF, popGet(AOP(result),2,FALSE,FALSE));
+         emitSKPNZ;
+         emitpcode(POC_INCF, popGet(AOP(result),3,FALSE,FALSE));
+
+       } 
+      } 
+    }
+
+*/
     }
   } else {
     int offset = 1;
@@ -509,48 +644,72 @@ static void genAddLit (operand *result,operand *left, int lit)
 
     if(size == 1) {
 
-      switch(lit & 0xff) {
-      case 0:
-       emitpcode(POC_MOVFW, popGet(AOP(left),0,FALSE,FALSE));
-       emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
-       break;
-      case 1:
-       emitpcode(POC_INCFW, popGet(AOP(left),0,FALSE,FALSE));
-       emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
-       break;
-      case 0xff:
-       emitpcode(POC_DECFW, popGet(AOP(left),0,FALSE,FALSE));
-       emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
-       break;
-      default:
-       emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
-       emitpcode(POC_ADDFW, popGet(AOP(left),0,FALSE,FALSE));
-       emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
+      if(AOP_TYPE(left) == AOP_ACC) {
+       /* left addend is already in accumulator */
+       switch(lit & 0xff) {
+       case 0:
+         //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
+         emitMOVWF(result,0);
+         break;
+       default:
+         emitpcode(POC_ADDLW, popGetLit(lit & 0xff));
+         //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
+         emitMOVWF(result,0);
+       }
+      } else {
+       /* left addend is in a register */
+       switch(lit & 0xff) {
+       case 0:
+         emitpcode(POC_MOVFW, popGet(AOP(left),0));
+         emitMOVWF(result, 0);
+         //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
+         emitMOVWF(result,0);
+         break;
+       case 1:
+         emitpcode(POC_INCFW, popGet(AOP(left),0));
+         //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
+         emitMOVWF(result,0);
+         break;
+       case 0xff:
+         emitpcode(POC_DECFW, popGet(AOP(left),0));
+         //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
+         emitMOVWF(result,0);
+         break;
+       default:
+         emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
+         emitpcode(POC_ADDFW, popGet(AOP(left),0));
+         //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
+         emitMOVWF(result,0);
+       }
       }
+
     } else {
 
+      /* left is not the accumulator */
       if(lit & 0xff) {
        emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
-       emitpcode(POC_ADDFW, popGet(AOP(left),0,FALSE,FALSE));
+       emitpcode(POC_ADDFW, popGet(AOP(left),0));
       } else
-       emitpcode(POC_MOVFW, popGet(AOP(left),0,FALSE,FALSE));
+       emitpcode(POC_MOVFW, popGet(AOP(left),0));
 
-      emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
+      //emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
+      emitMOVWF(result,0);
       lit >>= 8;
       while(--size) {
       
        if(lit & 0xff) {
          emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
-         emitpcode(POC_MOVWF, popGet(AOP(result),offset,FALSE,FALSE));
-         emitpcode(POC_MOVFW, popGet(AOP(left),offset,FALSE,FALSE));
+         //emitpcode(POC_MOVWF, popGet(AOP(result),offset,FALSE,FALSE));
+         emitMOVWF(result,offset);
+         emitpcode(POC_MOVFW, popGet(AOP(left),offset));
          emitSKPNC;
-         emitpcode(POC_INCFSZW,popGet(AOP(left),offset,FALSE,FALSE));
-         emitpcode(POC_ADDWF,  popGet(AOP(result),offset,FALSE,FALSE));
+         emitpcode(POC_INCFSZW,popGet(AOP(left),offset));
+         emitpcode(POC_ADDWF,  popGet(AOP(result),offset));
        } else {
-         emitpcode(POC_CLRF,  popGet(AOP(result),offset,FALSE,FALSE));
-         emitpcode(POC_RLF,   popGet(AOP(result),offset,FALSE,FALSE));
-         emitpcode(POC_MOVFW, popGet(AOP(left),offset,FALSE,FALSE));
-         emitpcode(POC_ADDWF, popGet(AOP(result),offset,FALSE,FALSE));
+         emitpcode(POC_CLRF,  popGet(AOP(result),offset));
+         emitpcode(POC_RLF,   popGet(AOP(result),offset));
+         emitpcode(POC_MOVFW, popGet(AOP(left),offset));
+         emitpcode(POC_ADDWF, popGet(AOP(result),offset));
        }
       offset++;
       }
@@ -572,6 +731,8 @@ void genPlus (iCode *ic)
   aopOp (IC_RIGHT(ic),ic,FALSE);
   aopOp (IC_RESULT(ic),ic,TRUE);
 
+  DEBUGpic14_AopType(__LINE__,IC_LEFT(ic),IC_RIGHT(ic),IC_RESULT(ic));
+
   /* if literal, literal on the right or
      if left requires ACC or right is already
      in ACC */
@@ -595,10 +756,10 @@ void genPlus (iCode *ic)
     /* if result in bit space */
     if(AOP_TYPE(IC_RESULT(ic)) == AOP_CRY){
       if((unsigned long)floatFromVal(AOP(IC_RIGHT(ic))->aopu.aop_lit) != 0L) {
-       emitpcode(POC_MOVLW, popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+       emitpcode(POC_MOVLW, popGet(AOP(IC_RESULT(ic)),0));
        if (!pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) )
-         emitpcode(POC_BTFSC, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
-       emitpcode(POC_XORWF, popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+         emitpcode(POC_BTFSC, popGet(AOP(IC_LEFT(ic)),0));
+       emitpcode(POC_XORWF, popGet(AOP(IC_RESULT(ic)),0));
       }
     } else {
       size = pic14_getDataSize(IC_RESULT(ic));
@@ -627,63 +788,8 @@ void genPlus (iCode *ic)
     //      offset = 0;
     DEBUGpic14_emitcode(";","adding lit to something. size %d",size);
 
-    genAddLit ( IC_RESULT(ic),IC_LEFT(ic),  lit);
-#if 0
-    while(size--){
-
-      DEBUGpic14_emitcode(";","size %d",size);
-
-      switch (lit & 0xff) {
-      case 0:
-       break;
-      case 1:
-       if(pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))))
-         emitpcode(POC_INCF, popGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE));
-       else {
-         know_W = 0;
-         emitpcode(POC_INCFW, popGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE));
-         if(AOP_TYPE(IC_RESULT(ic)) != AOP_ACC)
-           emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
-       }
-       break;
-      case 0xff:
-       if(pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))))
-         emitpcode(POC_DECF, popGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE));
-       else {
-         know_W = 0;
-         emitpcode(POC_DECFW, popGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE));
-         if(AOP_TYPE(IC_RESULT(ic)) != AOP_ACC)
-           emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
-       }
-       break;
-      default:
-       if( !know_W || ( (lit&0xff) != l1)  ) {
-         know_W = 1;
-         emitpcode(POC_MOVLW,popGetLit(lit&0xff));
-       }
-       if(pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic)))) {
-         emitpcode(POC_ADDWF, popGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE));
-         if(size) {
-           emitSKPNC;
-           emitpcode(POC_INCF, popGet(AOP(IC_LEFT(ic)),offset+1,FALSE,FALSE));
-         }
-
-       } else {
-         know_W = 0;
-         emitpcode(POC_ADDFW, popGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE));
-         emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
-         if(size) {
-           emitSKPNC;
-           emitpcode(POC_INCFW, popGet(AOP(IC_RESULT(ic)),offset+1,FALSE,FALSE));
-         }
-       }
-      }
-
-      l1 = lit & 0xff;
-      lit >>= 8;
-      offset++;
-    }
-#endif
+    genAddLit (ic,  lit);
+    goto release;
 
   } else if(AOP_TYPE(IC_RIGHT(ic)) == AOP_CRY) {
 
@@ -695,8 +801,8 @@ void genPlus (iCode *ic)
     if(size == 1) {
       if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
 
-       emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
-       emitpcode(POC_INCF ,  popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+       emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
+       emitpcode(POC_INCF ,  popGet(AOP(IC_RESULT(ic)),0));
 
        pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
                       AOP(IC_RIGHT(ic))->aopu.aop_dir,
@@ -705,7 +811,7 @@ void genPlus (iCode *ic)
       } else {
 
        if(AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) {
-         emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+         emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
          emitpcode(POC_XORLW , popGetLit(1));
 
          pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
@@ -713,9 +819,9 @@ void genPlus (iCode *ic)
                         AOP(IC_RIGHT(ic))->aopu.aop_dir);
          pic14_emitcode(" xorlw","1");
        } else {
-         emitpcode(POC_MOVFW , popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
-         emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
-         emitpcode(POC_INCFW , popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+         emitpcode(POC_MOVFW , popGet(AOP(IC_LEFT(ic)),0));
+         emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
+         emitpcode(POC_INCFW , popGet(AOP(IC_LEFT(ic)),0));
 
          pic14_emitcode("movf","%s,w", aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
          pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
@@ -728,11 +834,11 @@ void genPlus (iCode *ic)
            
          if(AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) {
            emitpcode(POC_ANDLW , popGetLit(1));
-           emitpcode(POC_BCF ,   popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+           emitpcode(POC_BCF ,   popGet(AOP(IC_RESULT(ic)),0));
            emitSKPZ;
-           emitpcode(POC_BSF ,   popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+           emitpcode(POC_BSF ,   popGet(AOP(IC_RESULT(ic)),0));
          } else {
-           emitpcode(POC_MOVWF ,   popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+           emitpcode(POC_MOVWF ,   popGet(AOP(IC_RESULT(ic)),0));
            pic14_emitcode("movwf","%s", aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
          }
        }
@@ -740,11 +846,11 @@ void genPlus (iCode *ic)
 
     } else {
       int offset = 1;
-
+      DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
       if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
        emitCLRZ;
-       emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
-       emitpcode(POC_INCF,  popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+       emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0));
+       emitpcode(POC_INCF,  popGet(AOP(IC_RESULT(ic)),0));
 
        pic14_emitcode("clrz","");
 
@@ -755,11 +861,11 @@ void genPlus (iCode *ic)
 
       } else {
 
-       emitpcode(POC_MOVFW, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
-       emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
-       emitpcode(POC_INCFW, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
-       emitpcode(POC_MOVWF, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
-
+       emitpcode(POC_MOVFW, popGet(AOP(IC_LEFT(ic)),0));
+       emitpcode(POC_BTFSC, popGet(AOP(IC_RIGHT(ic)),0));
+       emitpcode(POC_INCFW, popGet(AOP(IC_LEFT(ic)),0));
+       //emitpcode(POC_MOVWF, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+       emitMOVWF(IC_RIGHT(ic),0);
 
        pic14_emitcode("movf","%s,w", aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
        pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
@@ -772,58 +878,61 @@ void genPlus (iCode *ic)
 
       while(--size){
        emitSKPZ;
-       emitpcode(POC_INCF,  popGet(AOP(IC_RESULT(ic)),offset++,FALSE,FALSE));
+       emitpcode(POC_INCF,  popGet(AOP(IC_RESULT(ic)),offset++));
        //pic14_emitcode(" incf","%s,f", aopGet(AOP(IC_RIGHT(ic)),offset++,FALSE,FALSE));
       }
 
     }
       
   } else {
-    
+    DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);    
+
+    /* Add the first bytes */
+
     if(strcmp(aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE),"a") == 0 ) {
-      emitpcode(POC_ADDFW, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
-      emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+      emitpcode(POC_ADDFW, popGet(AOP(IC_RIGHT(ic)),0));
+      emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
     } else {
 
       if ( AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) {
-       emitpcode(POC_ADDFW, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+       emitpcode(POC_ADDFW, popGet(AOP(IC_RIGHT(ic)),0));
        if ( AOP_TYPE(IC_RESULT(ic)) != AOP_ACC)
-         emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+         emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
       } else {
 
-       emitpcode(POC_MOVFW,popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+       emitpcode(POC_MOVFW,popGet(AOP(IC_RIGHT(ic)),0));
 
        if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) )
-         emitpcode(POC_ADDWF, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+         emitpcode(POC_ADDWF, popGet(AOP(IC_LEFT(ic)),0));
        else {
-         if( (AOP_TYPE(IC_LEFT(ic)) == AOP_IMMD) ||
-             (AOP_TYPE(IC_LEFT(ic)) == AOP_LIT) ) {
-           emitpcode(POC_ADDLW, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
-         } else {
-           emitpcode(POC_ADDFW, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
-           if ( AOP_TYPE(IC_RESULT(ic)) != AOP_ACC)
-             emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
-         }
+         PIC_OPCODE poc = POC_ADDFW;
+
+         if ((AOP_TYPE(IC_LEFT(ic)) == AOP_PCODE) && AOP(IC_LEFT(ic))->aopu.pcop->type == PO_LITERAL)
+           poc = POC_ADDLW;
+         emitpcode(poc, popGet(AOP(IC_LEFT(ic)),0));
+         if ( AOP_TYPE(IC_RESULT(ic)) != AOP_ACC)
+           emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
        }
       }
     }
 
+    size = min( AOP_SIZE(IC_RESULT(ic)), AOP_SIZE(IC_RIGHT(ic))) - 1;
     offset = 1;
-    size--;
+
 
     while(size--){
       if (!pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
-       emitpcode(POC_MOVFW, popGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE));
-       emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
+       emitpcode(POC_MOVFW, popGet(AOP(IC_LEFT(ic)),offset));
+       emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
 
        pic14_emitcode("movf","%s,w",  aopGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE));
        pic14_emitcode("movwf","%s",  aopGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
       }
 
-      emitpcode(POC_MOVFW,   popGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));
+      emitpcode(POC_MOVFW,   popGet(AOP(IC_RIGHT(ic)),offset));
       emitSKPNC;
-      emitpcode(POC_INCFSZW, popGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));
-      emitpcode(POC_ADDWF,   popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
+      emitpcode(POC_INCFSZW, popGet(AOP(IC_RIGHT(ic)),offset));
+      emitpcode(POC_ADDWF,   popGet(AOP(IC_RESULT(ic)),offset));
 
       /*
        pic14_emitcode("movf","%s,w",  aopGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));
@@ -837,6 +946,49 @@ void genPlus (iCode *ic)
 
   }
 
+  if (AOP_SIZE(IC_RESULT(ic)) > AOP_SIZE(IC_RIGHT(ic))) {
+    int sign =  !(SPEC_USIGN(getSpec(operandType(IC_LEFT(ic)))) |
+                 SPEC_USIGN(getSpec(operandType(IC_RIGHT(ic)))) );
+
+
+    /* Need to extend result to higher bytes */
+    size = AOP_SIZE(IC_RESULT(ic)) - AOP_SIZE(IC_RIGHT(ic)) - 1;
+
+    /* First grab the carry from the lower bytes */
+    emitpcode(POC_CLRF, popGet(AOP(IC_RESULT(ic)),offset));
+    emitpcode(POC_RLF,  popGet(AOP(IC_RESULT(ic)),offset));
+
+
+    if(sign) {
+      /* Now this is really horrid. Gotta check the sign of the addends and propogate
+       * to the result */
+
+      emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(IC_LEFT(ic)),offset-1,FALSE,FALSE),7,0));
+      emitpcode(POC_DECF,  popGet(AOP(IC_RESULT(ic)),offset));
+      emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(IC_RIGHT(ic)),offset-1,FALSE,FALSE),7,0));
+      emitpcode(POC_DECF,  popGet(AOP(IC_RESULT(ic)),offset));
+
+      /* if chars or ints or being signed extended to longs: */
+      if(size) {
+       emitpcode(POC_MOVLW, popGetLit(0));
+       emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE),7,0));
+       emitpcode(POC_MOVLW, popGetLit(0xff));
+      }
+    }
+
+    offset++;
+    while(size--) {
+      
+      if(sign)
+       emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
+      else
+       emitpcode(POC_CLRF,  popGet(AOP(IC_RESULT(ic)),offset));
+
+      offset++;
+    }
+  }
+
+
   //adjustArithmeticResult(ic);
 
  release:
@@ -875,10 +1027,10 @@ bool genMinusDec (iCode *ic)
         (icount == 1)) {
 
       if(size == 2) { 
-       emitpcode(POC_DECF,    popGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
-       emitpcode(POC_INCFSZW, popGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
-       emitpcode(POC_INCF,    popGet(AOP(IC_RESULT(ic)),MSB16,FALSE,FALSE));
-       emitpcode(POC_DECF,    popGet(AOP(IC_RESULT(ic)),MSB16,FALSE,FALSE));
+       emitpcode(POC_DECF,    popGet(AOP(IC_RESULT(ic)),LSB));
+       emitpcode(POC_INCFSZW, popGet(AOP(IC_RESULT(ic)),LSB));
+       emitpcode(POC_INCF,    popGet(AOP(IC_RESULT(ic)),MSB16));
+       emitpcode(POC_DECF,    popGet(AOP(IC_RESULT(ic)),MSB16));
 
        pic14_emitcode("decf","%s,f",aopGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
        pic14_emitcode("incfsz","%s,w",aopGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
@@ -886,11 +1038,11 @@ bool genMinusDec (iCode *ic)
       } else {
        /* size is 3 or 4 */
        emitpcode(POC_MOVLW,  popGetLit(0xff));
-       emitpcode(POC_ADDWF,  popGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
+       emitpcode(POC_ADDWF,  popGet(AOP(IC_RESULT(ic)),LSB));
        emitSKPNC;
-       emitpcode(POC_ADDWF,  popGet(AOP(IC_RESULT(ic)),MSB16,FALSE,FALSE));
+       emitpcode(POC_ADDWF,  popGet(AOP(IC_RESULT(ic)),MSB16));
        emitSKPNC;
-       emitpcode(POC_ADDWF,  popGet(AOP(IC_RESULT(ic)),MSB24,FALSE,FALSE));
+       emitpcode(POC_ADDWF,  popGet(AOP(IC_RESULT(ic)),MSB24));
 
        pic14_emitcode("movlw","0xff");
        pic14_emitcode("addwf","%s,f",aopGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
@@ -902,7 +1054,7 @@ bool genMinusDec (iCode *ic)
 
        if(size > 3) {
          emitSKPNC;
-         emitpcode(POC_ADDWF,  popGet(AOP(IC_RESULT(ic)),MSB32,FALSE,FALSE));
+         emitpcode(POC_ADDWF,  popGet(AOP(IC_RESULT(ic)),MSB32));
 
          pic14_emitcode("skpnc","");
          emitSKPNC;
@@ -926,7 +1078,7 @@ bool genMinusDec (iCode *ic)
     if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic)))) {
 
       while (icount--) 
-       emitpcode(POC_DECF, popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+       emitpcode(POC_DECF, popGet(AOP(IC_RESULT(ic)),0));
 
        //pic14_emitcode ("decf","%s,f",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
 
@@ -941,8 +1093,8 @@ bool genMinusDec (iCode *ic)
       pic14_emitcode("decf","%s,w",aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
       pic14_emitcode("movwf","%s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
 
-      emitpcode(POC_DECFW,  popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
-      emitpcode(POC_MOVWF,  popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+      emitpcode(POC_DECFW,  popGet(AOP(IC_LEFT(ic)),0));
+      emitpcode(POC_MOVWF,  popGet(AOP(IC_RESULT(ic)),0));
 
       return TRUE;
     }
@@ -951,22 +1103,33 @@ bool genMinusDec (iCode *ic)
 }
 
 /*-----------------------------------------------------------------*/
-/* addSign - complete with sign                                    */
+/* addSign - propogate sign bit to higher bytes                    */
 /*-----------------------------------------------------------------*/
 void addSign(operand *result, int offset, int sign)
 {
-    int size = (pic14_getDataSize(result) - offset);
-    DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-    if(size > 0){
-        if(sign){
-            pic14_emitcode("rlc","a");
-            pic14_emitcode("subb","a,acc");
-            while(size--)
-                aopPut(AOP(result),"a",offset++); 
-        } else
-            while(size--)
-                aopPut(AOP(result),"#0",offset++);
-    }
+  int size = (pic14_getDataSize(result) - offset);
+  DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+
+  if(size > 0){
+    if(sign && offset) {
+
+      if(size == 1) {
+       emitpcode(POC_CLRF,popGet(AOP(result),offset));
+       emitpcode(POC_BTFSC,newpCodeOpBit(aopGet(AOP(result),offset-1,FALSE,FALSE),7,0));
+       emitpcode(POC_DECF, popGet(AOP(result),offset));
+      } else {
+
+       emitpcode(POC_MOVLW, popGetLit(0));
+       emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(result),offset-1,FALSE,FALSE),7,0));
+       emitpcode(POC_MOVLW, popGetLit(0xff));
+       while(size--)
+         emitpcode(POC_MOVWF, popGet(AOP(result),size));
+
+      }
+    } else
+      while(size--)
+       emitpcode(POC_CLRF,popGet(AOP(result),offset++));
+  }
 }
 
 /*-----------------------------------------------------------------*/
@@ -999,7 +1162,7 @@ void genMinusBits (iCode *ic)
 /*-----------------------------------------------------------------*/
 void genMinus (iCode *ic)
 {
-  int size, offset = 0,same;
+  int size, offset = 0, same=0;
   unsigned long lit = 0L;
 
   DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
@@ -1041,14 +1204,14 @@ void genMinus (iCode *ic)
     lit = (unsigned long)floatFromVal(AOP(IC_RIGHT(ic))->aopu.aop_lit);
     lit = - (long)lit;
 
-    genAddLit ( IC_RESULT(ic),IC_LEFT(ic),  lit);
+    genAddLit ( ic,  lit);
     
 #if 0
     /* add the first byte: */
     pic14_emitcode("movlw","0x%x", lit & 0xff);
     pic14_emitcode("addwf","%s,f", aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
     emitpcode(POC_MOVLW,  popGetLit(lit & 0xff));
-    emitpcode(POC_ADDWF,  popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+    emitpcode(POC_ADDWF,  popGet(AOP(IC_LEFT(ic)),0));
 
 
     offset = 1;
@@ -1063,19 +1226,19 @@ void genMinus (iCode *ic)
        if((lit & 0xff) == 0xff) {
          emitpcode(POC_MOVLW,  popGetLit(0xff));
          emitSKPC;
-         emitpcode(POC_ADDWF,  popGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE));
+         emitpcode(POC_ADDWF,  popGet(AOP(IC_LEFT(ic)),offset));
        } else {
          emitpcode(POC_MOVLW,  popGetLit(lit & 0xff));
          emitSKPNC;
          emitpcode(POC_MOVLW,  popGetLit((lit+1) & 0xff));
-         emitpcode(POC_ADDWF,  popGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE));
+         emitpcode(POC_ADDWF,  popGet(AOP(IC_LEFT(ic)),offset));
        }
 
       } else {
        /* do the rlf known zero trick here */
        emitpcode(POC_MOVLW,  popGetLit(1));
        emitSKPNC;
-       emitpcode(POC_ADDWF,  popGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE));
+       emitpcode(POC_ADDWF,  popGet(AOP(IC_LEFT(ic)),offset));
       }
       offset++;
     }
@@ -1091,8 +1254,8 @@ void genMinus (iCode *ic)
     if(size == 1) {
       if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
 
-       emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
-       emitpcode(POC_DECF ,  popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+       emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
+       emitpcode(POC_DECF ,  popGet(AOP(IC_RESULT(ic)),0));
 
        pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
                 AOP(IC_RIGHT(ic))->aopu.aop_dir,
@@ -1101,7 +1264,7 @@ void genMinus (iCode *ic)
       } else {
 
        if(AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) {
-         emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+         emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
          emitpcode(POC_XORLW , popGetLit(1));
        }else  if( (AOP_TYPE(IC_LEFT(ic)) == AOP_IMMD) ||
              (AOP_TYPE(IC_LEFT(ic)) == AOP_LIT) ) {
@@ -1111,35 +1274,35 @@ void genMinus (iCode *ic)
          if(AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) {
            if (pic14_sameRegs(AOP(IC_RIGHT(ic)), AOP(IC_RESULT(ic))) ) {
              if(lit & 1) {
-               emitpcode(POC_MOVLW , popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
-               emitpcode(POC_XORWF , popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+               emitpcode(POC_MOVLW , popGet(AOP(IC_RIGHT(ic)),0));
+               emitpcode(POC_XORWF , popGet(AOP(IC_RIGHT(ic)),0));
              }
            }else{
-             emitpcode(POC_BCF ,     popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+             emitpcode(POC_BCF ,     popGet(AOP(IC_RESULT(ic)),0));
              if(lit & 1) 
-               emitpcode(POC_BTFSS , popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+               emitpcode(POC_BTFSS , popGet(AOP(IC_RIGHT(ic)),0));
              else
-               emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
-             emitpcode(POC_BSF ,     popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+               emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
+             emitpcode(POC_BSF ,     popGet(AOP(IC_RESULT(ic)),0));
            }
            goto release;
          } else {
            emitpcode(POC_MOVLW , popGetLit(lit & 0xff));
-           emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+           emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
            emitpcode(POC_MOVLW , popGetLit((lit-1) & 0xff));
-           emitpcode(POC_MOVWF , popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+           emitpcode(POC_MOVWF , popGet(AOP(IC_RESULT(ic)),0));
 
          }
 
        } else {
-         emitpcode(POC_MOVFW , popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
-         emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
-         emitpcode(POC_DECFW , popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+         emitpcode(POC_MOVFW , popGet(AOP(IC_LEFT(ic)),0));
+         emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0));
+         emitpcode(POC_DECFW , popGet(AOP(IC_LEFT(ic)),0));
        }
          
        if(AOP_TYPE(IC_RESULT(ic)) != AOP_ACC) {
            
-         emitpcode(POC_MOVWF ,   popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+         emitpcode(POC_MOVWF ,   popGet(AOP(IC_RESULT(ic)),0));
 
        } else  {
          emitpcode(POC_ANDLW , popGetLit(1));
@@ -1167,17 +1330,19 @@ void genMinus (iCode *ic)
     if( (size == 1) && ((lit & 0xff) == 0) ) {
       /* res = 0 - right */
       if (pic14_sameRegs(AOP(IC_RIGHT(ic)), AOP(IC_RESULT(ic))) ) {
-       emitpcode(POC_COMF,  popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+       emitpcode(POC_COMF,  popGet(AOP(IC_RIGHT(ic)),0));
+       emitpcode(POC_INCF,  popGet(AOP(IC_RIGHT(ic)),0));
       } else { 
-       emitpcode(POC_MOVFW,  popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
-       emitpcode(POC_MOVWF,  popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+       emitpcode(POC_COMFW,  popGet(AOP(IC_RIGHT(ic)),0));
+       emitpcode(POC_MOVWF,  popGet(AOP(IC_RESULT(ic)),0));
+       emitpcode(POC_INCF,   popGet(AOP(IC_RESULT(ic)),0));
       }
       goto release;
     }
 
-    emitpcode(POC_MOVFW,  popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+    emitpcode(POC_MOVFW,  popGet(AOP(IC_RIGHT(ic)),0));
     emitpcode(POC_SUBLW, popGetLit(lit & 0xff));    
-    emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+    emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
 
 
     offset = 1;
@@ -1191,21 +1356,21 @@ void genMinus (iCode *ic)
        if(lit == 0xff) {
          /* 0xff - x == ~x */
          if(same) {
-           emitpcode(POC_COMF,  popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
+           emitpcode(POC_COMF,  popGet(AOP(IC_RESULT(ic)),offset));
            emitSKPC;
-           emitpcode(POC_DECF,  popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
+           emitpcode(POC_DECF,  popGet(AOP(IC_RESULT(ic)),offset));
          } else {
-           emitpcode(POC_COMFW, popGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));
-           emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
+           emitpcode(POC_COMFW, popGet(AOP(IC_RIGHT(ic)),offset));
+           emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
            emitSKPC;
-           emitpcode(POC_DECF,  popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
+           emitpcode(POC_DECF,  popGet(AOP(IC_RESULT(ic)),offset));
          }
        } else {
-           emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));
+           emitpcode(POC_MOVFW, popGet(AOP(IC_RIGHT(ic)),offset));
            emitSKPC;
-           emitpcode(POC_INCFW, popGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));
+           emitpcode(POC_INCFW, popGet(AOP(IC_RIGHT(ic)),offset));
            emitpcode(POC_SUBLW, popGetLit(lit & 0xff));
-           emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
+           emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
        }
 
        goto release;
@@ -1217,24 +1382,24 @@ void genMinus (iCode *ic)
          emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
          emitSKPC;
          emitpcode(POC_MOVLW, popGetLit((lit & 0xff)-1));
-         emitpcode(POC_SUBWF,  popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
+         emitpcode(POC_SUBWF,  popGet(AOP(IC_RESULT(ic)),offset));
        } else {
          emitSKPNC;
-         emitpcode(POC_SUBWF,  popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
+         emitpcode(POC_SUBWF,  popGet(AOP(IC_RESULT(ic)),offset));
 
        }
       } else {
 
        if(lit & 0xff) {
          emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
-         emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
+         emitpcode(POC_MOVWF, popGet(AOP(IC_RESULT(ic)),offset));
        } else
-         emitpcode(POC_CLRF, popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
+         emitpcode(POC_CLRF, popGet(AOP(IC_RESULT(ic)),offset));
 
-       emitpcode(POC_MOVFW,  popGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));
+       emitpcode(POC_MOVFW,  popGet(AOP(IC_RIGHT(ic)),offset));
        emitSKPC;
-       emitpcode(POC_INCFSZW,popGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));
-       emitpcode(POC_SUBWF,  popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
+       emitpcode(POC_INCFSZW,popGet(AOP(IC_RIGHT(ic)),offset));
+       emitpcode(POC_SUBWF,  popGet(AOP(IC_RESULT(ic)),offset));
       }
     }
   
@@ -1248,38 +1413,38 @@ void genMinus (iCode *ic)
 
     if(strcmp(aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE),"a") == 0 ) {
       DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-      emitpcode(POC_SUBFW, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+      emitpcode(POC_SUBFW, popGet(AOP(IC_RIGHT(ic)),0));
       emitpcode(POC_SUBLW, popGetLit(0));
-      emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+      emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
     } else {
 
       if ( AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) {
-       emitpcode(POC_SUBFW, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+       emitpcode(POC_SUBFW, popGet(AOP(IC_RIGHT(ic)),0));
        emitpcode(POC_SUBLW, popGetLit(0));
        if ( AOP_TYPE(IC_RESULT(ic)) != AOP_ACC)
-         emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+         emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
       } else {
 
        DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
        if(AOP_TYPE(IC_RIGHT(ic)) != AOP_ACC) 
-         emitpcode(POC_MOVFW,popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+         emitpcode(POC_MOVFW,popGet(AOP(IC_RIGHT(ic)),0));
 
        if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) )
-         emitpcode(POC_SUBWF, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+         emitpcode(POC_SUBWF, popGet(AOP(IC_LEFT(ic)),0));
        else {
          if( (AOP_TYPE(IC_LEFT(ic)) == AOP_IMMD) ||
              (AOP_TYPE(IC_LEFT(ic)) == AOP_LIT) ) {
-           emitpcode(POC_SUBLW, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+           emitpcode(POC_SUBLW, popGet(AOP(IC_LEFT(ic)),0));
          } else {
-           emitpcode(POC_SUBFW, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+           emitpcode(POC_SUBFW, popGet(AOP(IC_LEFT(ic)),0));
          }
          if ( AOP_TYPE(IC_RESULT(ic)) != AOP_ACC) {
            if ( AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) {
-             emitpcode(POC_BCF ,   popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+             emitpcode(POC_BCF ,   popGet(AOP(IC_RESULT(ic)),0));
              emitSKPZ;
-             emitpcode(POC_BSF ,   popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+             emitpcode(POC_BSF ,   popGet(AOP(IC_RESULT(ic)),0));
            }else
-             emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+             emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0));
          }
        }
       }
@@ -1300,13 +1465,13 @@ void genMinus (iCode *ic)
 
     while(size--){
       if (!pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
-       emitpcode(POC_MOVFW,  popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
-       emitpcode(POC_MOVWF,  popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+       emitpcode(POC_MOVFW,  popGet(AOP(IC_LEFT(ic)),offset));
+       emitpcode(POC_MOVWF,  popGet(AOP(IC_RESULT(ic)),offset));
       }
-      emitpcode(POC_MOVFW,  popGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));
+      emitpcode(POC_MOVFW,  popGet(AOP(IC_RIGHT(ic)),offset));
       emitSKPC;
-      emitpcode(POC_INCFSZW,popGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));
-      emitpcode(POC_SUBWF,  popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
+      emitpcode(POC_INCFSZW,popGet(AOP(IC_RIGHT(ic)),offset));
+      emitpcode(POC_SUBWF,  popGet(AOP(IC_RESULT(ic)),offset));
 
       offset++;
     }
@@ -1321,5 +1486,296 @@ void genMinus (iCode *ic)
   freeAsmop(IC_RIGHT(ic),NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
   freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
 }
+/*-----------------------------------------------------------------*
+ * genUMult8XLit_16 - unsigned multiplication of two 8-bit numbers.
+ * 
+ * 
+ *-----------------------------------------------------------------*/
+void genUMult8XLit_16 (operand *left,
+                      operand *right,
+                      operand *result,
+                      pCodeOpReg *result_hi)
+
+{
+
+  unsigned int lit;
+  unsigned int i,have_first_bit;
+  int same;
 
+  if (AOP_TYPE(right) != AOP_LIT){
+    fprintf(stderr,"%s %d - right operand is not a literal\n",__FILE__,__LINE__);
+    exit(1);
+  }
+
+
+  if(!result_hi) {
+    result_hi = PCOR(popGet(AOP(result),1));
+  }
+
+  lit = (unsigned int)floatFromVal(AOP(right)->aopu.aop_lit);
+  lit &= 0xff;
+  pic14_emitcode(";","Unrolled 8 X 8 multiplication");
+
+  same = pic14_sameRegs(AOP(left), AOP(result));
+
+  if(same) {
+    switch(lit) {
+    case 0:
+      emitpcode(POC_CLRF,  popGet(AOP(left),0));
+      return;
+    case 2:
+      emitpcode(POC_MOVFW, popGet(AOP(left),0));
+      emitpcode(POC_ADDWF, popGet(AOP(left),0));
+      return;
+    case 3:
+      emitpcode(POC_MOVFW, popGet(AOP(left),0));
+      emitpcode(POC_ADDWF, popGet(AOP(left),0));
+      emitpcode(POC_ADDWF, popGet(AOP(left),0));
+      return;
+    case 4:
+      emitpcode(POC_MOVFW, popGet(AOP(left),0));
+      emitpcode(POC_ADDWF, popGet(AOP(left),0));
+      emitpcode(POC_ADDWF, popGet(AOP(left),0));
+      return;
+    case 16:
+      emitpcode(POC_SWAPFW, popGet(AOP(left),0));
+      emitpcode(POC_ANDLW,  popGetLit(0xf0));
+      emitpcode(POC_MOVWF,  popGet(AOP(left),0));
+      return;
+    case 17:
+      emitpcode(POC_SWAPFW, popGet(AOP(left),0));
+      emitpcode(POC_ANDLW,  popGetLit(0xf0));
+      emitpcode(POC_ADDWF,  popGet(AOP(left),0));
+      return;
+
+    }
+  } else {
+
+    switch(lit) {
+    case 0:
+      emitpcode(POC_CLRF,  popGet(AOP(result),0));
+      emitpcode(POC_CLRF,  popCopyReg(result_hi));
+      return;
+    case 2:
+      emitpcode(POC_MOVFW, popGet(AOP(left),0));
+      emitpcode(POC_MOVWF, popGet(AOP(result),0));
+      emitpcode(POC_ADDWF, popGet(AOP(result),0));
+      emitpcode(POC_CLRF,  popCopyReg(result_hi));
+      emitpcode(POC_RLF,   popCopyReg(result_hi));
+      return;
+    }
+
+  }
+
+  emitpcode(POC_MOVFW, popGet(AOP(left),0));
+  emitpcode(POC_CLRF,  popGet(AOP(result),0));
+  emitpcode(POC_CLRF,  popCopyReg(result_hi));
+
+  have_first_bit = 0;
+  for(i=0; i<8; i++) {
+
+    if(lit & 1) {
+      emitpcode(POC_ADDWF, popCopyReg(result_hi));
+      have_first_bit = 1;
+    }
+
+    if(have_first_bit) {
+      emitpcode(POC_RRF,   popCopyReg(result_hi));
+      emitpcode(POC_RRF,   popGet(AOP(result),0));
+    }
+
+    lit >>= 1;
+  }
+
+}
+
+/*-----------------------------------------------------------------*
+ * genUMult8X8_16 - unsigned multiplication of two 8-bit numbers.
+ * 
+ * 
+ *-----------------------------------------------------------------*/
+void genUMult8X8_16 (operand *left,
+                    operand *right,
+                    operand *result,
+                    pCodeOpReg *result_hi)
+
+{
+
+  int i;
+  int looped = 1;
+
+  if(!result_hi) {
+    result_hi = PCOR(popGet(AOP(result),1));
+  }
+
+  if (AOP_TYPE(right) == AOP_LIT) {
+    genUMult8XLit_16(left,right,result,result_hi);
+    return;
+  }
+
+  if(!looped) {
+    pic14_emitcode(";","Unrolled 8 X 8 multiplication");
+
+    emitpcode(POC_MOVFW, popGet(AOP(right),0));
+    emitpcode(POC_CLRF,  popGet(AOP(result),0));
+    emitpcode(POC_CLRF,  popCopyReg(result_hi));
+    emitCLRC;
+
+    for(i=0; i<8; i++) {
+      emitpcode(POC_BTFSC,  newpCodeOpBit(aopGet(AOP(left),0,FALSE,FALSE),i,0));
+      emitpcode(POC_ADDWF, popCopyReg(result_hi));
+      emitpcode(POC_RRF,   popCopyReg(result_hi));
+      emitpcode(POC_RRF,   popGet(AOP(result),0));
+    }
 
+
+    /*
+      Here's another version that does the same thing and takes the 
+      same number of instructions. The one above is slightly better
+      because the entry instructions have a higher probability of
+      being optimized out.
+    */
+    /*
+      emitpcode(POC_CLRF,  popCopyReg(result_hi));
+      emitpcode(POC_RRFW,  popGet(AOP(left),0));
+      emitpcode(POC_MOVWF, popGet(AOP(result),0));
+      emitpcode(POC_MOVFW, popGet(AOP(right),0));
+
+      for(i=0; i<8; i++) {
+      emitSKPNC;
+      emitpcode(POC_ADDWF, popCopyReg(result_hi));
+      emitpcode(POC_RRF,   popCopyReg(result_hi));
+      emitpcode(POC_RRF,   popGet(AOP(result),0));
+      }
+    */
+
+  } else {
+    symbol  *tlbl = newiTempLabel(NULL);
+    pCodeOp *temp;
+
+
+    pic14_emitcode(";","Looped 8 X 8 multiplication");
+
+    emitpcode(POC_CLRF,  popGet(AOP(result),0));
+    emitpcode(POC_CLRF,  popCopyReg(result_hi));
+
+    emitpcode(POC_BSF,   newpCodeOpBit(aopGet(AOP(result),0,FALSE,FALSE),7,0));
+
+    emitpcode(POC_MOVFW, popGet(AOP(right),0));
+
+    temp = popGetTempReg();
+    emitpcode(POC_MOVWF, popCopyReg(PCOR(temp)));
+
+    emitpcode(POC_MOVFW, popGet(AOP(left),0));
+
+    emitpLabel(tlbl->key);
+
+    emitpcode(POC_RRF,   popCopyReg(PCOR(temp)));
+    emitSKPNC;
+    emitpcode(POC_ADDWF, popCopyReg(result_hi));
+
+    emitpcode(POC_RRF,   popCopyReg(result_hi));
+    emitpcode(POC_RRF,   popGet(AOP(result),0));
+
+    emitSKPC;
+    emitpcode(POC_GOTO,  popGetLabel(tlbl->key));
+
+    popReleaseTempReg(temp);
+
+  }
+}
+
+/*-----------------------------------------------------------------*
+ * genSMult8X8_16 - signed multiplication of two 8-bit numbers
+ *
+ *  this routine will call the unsigned multiply routine and then
+ * post-fix the sign bit.
+ *-----------------------------------------------------------------*/
+void genSMult8X8_16 (operand *left,
+                    operand *right,
+                    operand *result,
+                    pCodeOpReg *result_hi)
+{
+
+  if(!result_hi) {
+    result_hi = PCOR(popGet(AOP(result),1));
+  }
+
+  genUMult8X8_16(left,right,result,result_hi);
+
+  emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),0,FALSE,FALSE),7,0));
+  emitpcode(POC_SUBWF, popCopyReg(result_hi));
+  emitpcode(POC_MOVFW, popGet(AOP(left),0));
+  emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),7,0));
+  emitpcode(POC_SUBWF, popGet(AOP(result),1));
+  
+}
+
+/*-----------------------------------------------------------------*
+ * genMult8X8_8 - multiplication of two 8-bit numbers
+ *
+ *  this routine will call the unsigned multiply 8X8=>16 routine and
+ * then throw away the high byte of the result.
+ *
+ *-----------------------------------------------------------------*/
+void genMult8X8_8 (operand *left,
+                  operand *right,
+                  operand *result)
+{
+  pCodeOp *result_hi = popGetTempReg();
+
+  if (AOP_TYPE(right) == AOP_LIT)
+    genUMult8XLit_16(left,right,result,PCOR(result_hi));
+  else
+    genUMult8X8_16(left,right,result,PCOR(result_hi));
+
+  popReleaseTempReg(result_hi);
+}
+#if 0
+/*-----------------------------------------------------------------*/
+/* constMult - generates code for multiplication by a constant     */
+/*-----------------------------------------------------------------*/
+void genMultConst(unsigned C)
+{
+
+  unsigned lit;
+  unsigned sr3; // Shift right 3
+  unsigned mask;
+
+  int size = 1;
+
+  /*
+    Convert a string of 3 binary 1's in the lit into
+    0111 = 1000 - 1;
+  */
+
+  mask = 7 << ( (size*8) - 3);
+  lit = C;
+  sr3 = 0;
+
+  while(mask < (1<<size*8)) {
+
+    if( (mask & lit) == lit) {
+      unsigned lsb;
+
+      /* We found 3 (or more) consecutive 1's */
+
+      lsb = mask & ~(mask & (mask-1));  // lsb of mask.
+
+      consecutive_bits = ((lit + lsb) & lit) ^ lit;
+
+      lit ^= consecutive_bits;
+
+      mask <<= 3;
+
+      sr3 |= (consecutive + lsb);
+
+    }
+
+    mask >>= 1;
+
+  }
+
+}
+
+#endif
SDCC with magic sdcdb for TeleMetrum