projects / fw / sdcc / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
PIC Port - fixed pointer/array accesses. Stream line comparisons. Started function...
[fw/sdcc] / src / pic / genarith.c
diff --git a/src/pic/genarith.c b/src/pic/genarith.c
index 42cf9653e37af8bffc6b4979f360d9f9807ead58..de312a503aafa1efc7831f4a270325dbbf94bc24 100644 (file)
--- a/src/pic/genarith.c
+++ b/src/pic/genarith.c
@@ -65,6 +65,7 @@
 
 
 #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)
 {
@@ -105,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";
@@ -118,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 
@@ -141,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));
       }
 
@@ -158,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);
@@ -170,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);
@@ -190,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 ;
 }
 
@@ -228,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;
+  }
 
 }
 
@@ -365,18 +380,32 @@ 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 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)
 {
 
@@ -413,21 +442,21 @@ static void genAddLit (iCode *ic, 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));
 
 
        }
@@ -438,19 +467,19 @@ static void genAddLit (iCode *ic, 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;
 
@@ -459,11 +488,11 @@ static void genAddLit (iCode *ic, 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));
@@ -473,9 +502,9 @@ static void genAddLit (iCode *ic, 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));
          
        }
 
@@ -491,9 +520,9 @@ static void genAddLit (iCode *ic, 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));
@@ -503,11 +532,11 @@ static void genAddLit (iCode *ic, 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;
        }
 
@@ -527,16 +556,16 @@ static void genAddLit (iCode *ic, int lit)
            switch(carry_info) {
            case 1:
              emitSKPNZ;
-             emitpcode(POC_INCF, popGet(AOP(result),offset,FALSE,FALSE));
+             emitpcode(POC_INCF, popGet(AOP(result),offset));
              break;
            case 2:
-             emitpcode(POC_RLFW, popGet(AOP(result),offset,FALSE,FALSE));
+             emitpcode(POC_RLFW, popGet(AOP(result),offset));
              emitpcode(POC_ANDLW,popGetLit(1));
-             emitpcode(POC_ADDWF, popGet(AOP(result),offset,FALSE,FALSE));
+             emitpcode(POC_ADDWF, popGet(AOP(result),offset));
              break;
            default: /* carry_info = 3  */
              emitSKPNC;
-             emitpcode(POC_INCF, popGet(AOP(result),offset,FALSE,FALSE));
+             emitpcode(POC_INCF, popGet(AOP(result),offset));
              carry_info = 1;
              break;
            }
@@ -547,7 +576,7 @@ static void genAddLit (iCode *ic, int lit)
              emitSKPZ;
            else
              emitSKPC;
-           emitpcode(POC_ADDWF, popGet(AOP(result),offset,FALSE,FALSE));
+           emitpcode(POC_ADDWF, popGet(AOP(result),offset));
            break;
          default:
            emitpcode(POC_MOVLW,popGetLit(lo));
@@ -556,7 +585,7 @@ static void genAddLit (iCode *ic, int lit)
            else
              emitSKPNC;
            emitpcode(POC_MOVLW,popGetLit(lo+1));
-           emitpcode(POC_ADDWF, popGet(AOP(result),offset,FALSE,FALSE));
+           emitpcode(POC_ADDWF, popGet(AOP(result),offset));
            carry_info=2;
            break;
          }
@@ -567,12 +596,12 @@ static void genAddLit (iCode *ic, int lit)
          case 0:
            break;
          case 1:
-           emitpcode(POC_INCF, popGet(AOP(result),offset,FALSE,FALSE));
+           emitpcode(POC_INCF, popGet(AOP(result),offset));
            carry_info=1;
            break;
          default:
            emitpcode(POC_MOVLW,popGetLit(lo));
-           emitpcode(POC_ADDWF, popGet(AOP(result),offset,FALSE,FALSE));
+           emitpcode(POC_ADDWF, popGet(AOP(result),offset));
            if(lit <0x100) 
              carry_info = 3;  /* Were adding only one byte and propogating the carry */
            else
@@ -619,58 +648,68 @@ static void genAddLit (iCode *ic, int lit)
        /* left addend is already in accumulator */
        switch(lit & 0xff) {
        case 0:
-         emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
+         //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));
+         //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,FALSE,FALSE));
-         emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
+         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,FALSE,FALSE));
-         emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
+         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,FALSE,FALSE));
-         emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
+         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,FALSE,FALSE));
-         emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
+         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++;
       }
@@ -692,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 */
@@ -715,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));
@@ -748,62 +789,7 @@ void genPlus (iCode *ic)
     DEBUGpic14_emitcode(";","adding lit to something. size %d",size);
 
     genAddLit (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
+    goto release;
 
   } else if(AOP_TYPE(IC_RIGHT(ic)) == AOP_CRY) {
 
@@ -815,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,
@@ -825,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)",
@@ -833,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)",
@@ -848,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));
          }
        }
@@ -860,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","");
 
@@ -875,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)",
@@ -892,58 +878,63 @@ 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_PCODE) ||
              (AOP_TYPE(IC_LEFT(ic)) == AOP_LIT) ) {
-           emitpcode(POC_ADDLW, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+           emitpcode(POC_ADDLW, popGet(AOP(IC_LEFT(ic)),0));
          } 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));
+           emitpcode(POC_ADDFW, 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));
@@ -957,6 +948,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:
@@ -995,10 +1029,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));
@@ -1006,11 +1040,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));
@@ -1022,7 +1056,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;
@@ -1046,7 +1080,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));
 
@@ -1061,8 +1095,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;
     }
@@ -1071,22 +1105,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++));
+  }
 }
 
 /*-----------------------------------------------------------------*/
@@ -1139,10 +1184,6 @@ void genMinus (iCode *ic)
                   AopType(AOP_TYPE(IC_LEFT(ic))),
                   AopType(AOP_TYPE(IC_RIGHT(ic))));
 
-  DEBUGpic14_emitcode ("; ","same = %d, result-%s  left-%s",same,
-                      aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE),
-                      aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
-
   /* special cases :- */
   /* if both left & right are in bit space */
   if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY &&
@@ -1172,7 +1213,7 @@ void genMinus (iCode *ic)
     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;
@@ -1187,19 +1228,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++;
     }
@@ -1215,8 +1256,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,
@@ -1225,7 +1266,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) ) {
@@ -1235,35 +1276,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));
@@ -1291,17 +1332,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;
@@ -1315,21 +1358,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;
@@ -1341,24 +1384,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));
       }
     }
   
@@ -1372,38 +1415,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));
          }
        }
       }
@@ -1424,13 +1467,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)),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));
       }
-      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++;
     }
@@ -1445,5 +1488,243 @@ 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;
+
+  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");
+
+
+  if(!lit) {
+    emitpcode(POC_CLRF,  popGet(AOP(result),0));
+    emitpcode(POC_CLRF,  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(!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 = popGetTempReg();
+
+
+    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));
+    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