Added new regression test add2.c - tests adding lit's to unsigned ints. Literal addit...

git-svn-id: https://sdcc.svn.sourceforge.net/svnroot/sdcc/trunk/sdcc@1345 4a8a32a2-be11-0410-ad9d-d568d2c75423

diff --git a/src/pic/gen.c b/src/pic/gen.c
index f1bf622aba4ba0e9368a7a682d988d8d477331fb..3f136f1c75b7e1e70ed1dd0fa9166530224bf4ed 100644 (file)
--- a/src/pic/gen.c
+++ b/src/pic/gen.c
@@ -3805,7 +3805,7 @@ static void genCmpEq (iCode *ic, iCode *ifx)
                    emitpcode(POC_MOVFW,popGet(AOP(left),offset,FALSE,FALSE));
                    emitpcode(POC_XORLW,popGetLit(l));
                    emitpcode(POC_MOVLW,popGetLit(h));
-                   emitSKPZ;
+                   emitSKPNZ;
                    emitpcode(POC_XORFW,popGet(AOP(left),offset+1,FALSE,FALSE));
 /*
                    pic14_emitcode("movf","%s,w",aopGet(AOP(left),offset,FALSE,FALSE));

diff --git a/src/pic/genarith.c b/src/pic/genarith.c
index 643b179680abf7e419cc3098742ff70e07306aa4..f76ea06eb59d4dafa765bdcee18d9054c4ae73d3 100644 (file)
--- a/src/pic/genarith.c
+++ b/src/pic/genarith.c
@@ -310,281 +310,497 @@ static void adjustArithmeticResult(iCode *ic)
 #endif
 
 /*-----------------------------------------------------------------*/
-/* genPlus - generates code for addition                           */
+/* genAddlit - generates code for addition                         */
 /*-----------------------------------------------------------------*/
-void genPlus (iCode *ic)
+static void genAddLit2byte (operand *result, int offr, int lit)
 {
-    int size, offset = 0;
-
-    /* special cases :- */
-    DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
 
-    aopOp (IC_LEFT(ic),ic,FALSE);
-    aopOp (IC_RIGHT(ic),ic,FALSE);
-    aopOp (IC_RESULT(ic),ic,TRUE);
-
-    /* if literal, literal on the right or
-       if left requires ACC or right is already
-       in ACC */
+  switch(lit & 0xff) {
+  case 0:
+    break;
+  case 1:
+    emitpcode(POC_INCF, popGet(AOP(result),offr,FALSE,FALSE));
+    break;
+  case 0xff:
+    emitpcode(POC_DECF, popGet(AOP(result),offr,FALSE,FALSE));
+    break;
+  default:
+    emitpcode(POC_MOVLW,popGetLit(lit&0xff));
+    emitpcode(POC_ADDWF,popGet(AOP(result),offr,FALSE,FALSE));
+  }
 
-    if (AOP_TYPE(IC_LEFT(ic)) == AOP_LIT) {
-        operand *t = IC_RIGHT(ic);
-        IC_RIGHT(ic) = IC_LEFT(ic);
-        IC_LEFT(ic) = t;
-    }
+}
 
-    /* if both left & right are in bit space */
-    if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY &&
-        AOP_TYPE(IC_RIGHT(ic)) == AOP_CRY) {
-        genPlusBits (ic);
-        goto release ;
-    }
+static void genAddLit (operand *result,operand *left, int lit)
+{
 
-    /* if left in bit space & right literal */
-    if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY &&
-        AOP_TYPE(IC_RIGHT(ic)) == AOP_LIT) {
-        /* if result in bit space */
-        if(AOP_TYPE(IC_RESULT(ic)) == AOP_CRY){
-         if((unsigned long)floatFromVal(AOP(IC_RIGHT(ic))->aopu.aop_lit) != 0L) {
-           emitpcode(POC_MOVLW, popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
-           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));
-         }
-        } else {
-            size = pic14_getDataSize(IC_RESULT(ic));
-            while (size--) {
-                MOVA(aopGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));  
-                pic14_emitcode("addc","a,#00  ;%d",__LINE__);
-                aopPut(AOP(IC_RESULT(ic)),"a",offset++);
-            }
-        }
-        goto release ;
-    }
+  int size,same;
+  int knowW=0,W=0,needC=0;
 
-    /* if I can do an increment instead
-    of add then GOOD for ME */
-    if (genPlusIncr (ic) == TRUE)
-        goto release;   
+  DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+  size = pic14_getDataSize(result);
 
-    size = pic14_getDataSize(IC_RESULT(ic));
+  same = ((left == result) || (AOP(left) == AOP(result)));
 
-    if(AOP(IC_RIGHT(ic))->type == AOP_LIT) {
-      /* Add a literal to something else */
-      bool know_W=0;
-      unsigned lit = (unsigned) floatFromVal(AOP(IC_RIGHT(ic))->aopu.aop_lit);
-      unsigned l1=0;
+  if(same) {
 
-      offset = 0;
-      DEBUGpic14_emitcode(";","adding lit to something. size %d",size);
-      while(size--){
+    /* Handle special cases first */
+    if(size == 1) 
+      genAddLit2byte (result, 0, lit);
+     
+    else if(size == 2) {
+      int hi = 0xff & (lit >> 8);
+      int lo = lit & 0xff;
 
-      DEBUGpic14_emitcode(";","size %d",size);
+      switch(hi) {
+      case 0: 
 
-       switch (lit & 0xff) {
+       /* lit = 0x00LL */
+       DEBUGpic14_emitcode ("; hi = 0","%s  %d",__FUNCTION__,__LINE__);
+       switch(lo) {
        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));
-         }
+         emitpcode(POC_INCF, popGet(AOP(result),0,FALSE,FALSE));
+         emitSKPNZ;
+         emitpcode(POC_INCF, popGet(AOP(result),MSB16,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));
-         }
+         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));   
+
          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));
-         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_INCF, popGet(AOP(IC_LEFT(ic)),offset+1,FALSE,FALSE));
-           }
-         }
+         emitpcode(POC_MOVLW,popGetLit(lit&0xff));
+         emitpcode(POC_ADDWF,popGet(AOP(result),0,FALSE,FALSE));
+         emitSKPNC;
+         emitpcode(POC_INCF, popGet(AOP(result),MSB16,FALSE,FALSE));   
+
+
+       }
+       break;
+
+      case 1:
+       /* lit = 0x01LL */
+       DEBUGpic14_emitcode ("; hi = 1","%s  %d",__FUNCTION__,__LINE__);
+       switch(lo) {
+       case 0:  /* 0x0100 */
+         emitpcode(POC_INCF, popGet(AOP(result),MSB16,FALSE,FALSE));   
+         break;
+       case 1:  /* 0x0101  */
+         emitpcode(POC_INCF, popGet(AOP(result),MSB16,FALSE,FALSE));
+         emitpcode(POC_INCF, popGet(AOP(result),0,FALSE,FALSE));
+         emitSKPNZ;
+         emitpcode(POC_INCF, popGet(AOP(result),MSB16,FALSE,FALSE));   
+         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));   
+       }         
+       break;
+
+      case 0xff:
+       DEBUGpic14_emitcode ("; hi = ff","%s  %d",__FUNCTION__,__LINE__);
+       /* lit = 0xffLL */
+       switch(lo) {
+       case 0:  /* 0xff00 */
+         emitpcode(POC_DECF, popGet(AOP(result),MSB16,FALSE,FALSE));
+         break;
+       case 1:  /*0xff01 */
+         emitpcode(POC_INCFSZ, popGet(AOP(result),0,FALSE,FALSE));
+         emitpcode(POC_DECF, popGet(AOP(result),MSB16,FALSE,FALSE));
+         break;
+/*     case 0xff: * 0xffff *
+         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,FALSE,FALSE));
+         break;
+*/
+       default:
+         emitpcode(POC_MOVLW,popGetLit(lo));
+         emitpcode(POC_ADDWF,popGet(AOP(result),0,FALSE,FALSE));
+         emitSKPC;
+         emitpcode(POC_DECF, popGet(AOP(result),MSB16,FALSE,FALSE));
+         
        }
 
-       l1 = lit & 0xff;
-       lit >>= 8;
-       offset++;
-      }
+       break;
+       
+      default:
+       DEBUGpic14_emitcode ("; hi is generic","%d   %s  %d",hi,__FUNCTION__,__LINE__);
 
-    } else if(AOP_TYPE(IC_RIGHT(ic)) == AOP_CRY) {
+       /* lit = 0xHHLL */
+       switch(lo) {
+       case 0:  /* 0xHH00 */
+         genAddLit2byte (result, MSB16, hi);
+         break;
+       case 1:  /* 0xHH01 */
+         emitpcode(POC_MOVLW,popGetLit((hi+1)&0xff));
+         emitpcode(POC_INCFSZ, popGet(AOP(result),0,FALSE,FALSE));
+         emitpcode(POC_MOVLW,popGetLit(hi));
+         emitpcode(POC_ADDWF,popGet(AOP(result),MSB16,FALSE,FALSE));
+         break;
+/*     case 0xff: * 0xHHff *
+         emitpcode(POC_MOVFW, popGet(AOP(result),0,FALSE,FALSE));
+         emitpcode(POC_DECF, popGet(AOP(result),MSB16,FALSE,FALSE));
+         emitpcode(POC_MOVLW,popGetLit(hi));
+         emitpcode(POC_ADDWF,popGet(AOP(result),MSB16,FALSE,FALSE));
+         break;
+*/     default:  /* 0xHHLL */
+         emitpcode(POC_MOVLW,popGetLit(lo));
+         emitpcode(POC_ADDWF, popGet(AOP(result),0,FALSE,FALSE));
+         emitpcode(POC_MOVLW,popGetLit(hi));
+         emitSKPNC;
+         emitpcode(POC_MOVLW,popGetLit((hi+1) & 0xff));
+         emitpcode(POC_ADDWF,popGet(AOP(result),MSB16,FALSE,FALSE));
+         break;
+       }
 
-      pic14_emitcode(";bitadd","right is bit: %s",aopGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
-      pic14_emitcode(";bitadd","left is bit: %s",aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
-      pic14_emitcode(";bitadd","result is bit: %s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+      }
+    }
+  } else {
+    int offset = 1;
+    DEBUGpic14_emitcode (";  left and result aren't same","%s  %d",__FUNCTION__,__LINE__);
 
-      /* here we are adding a bit to a char or int */
-      if(size == 1) {
-       if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
+    if(size == 1) {
 
-         emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
-         emitpcode(POC_INCF ,  popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+      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));
+      }
+    } else {
 
-         pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
-                  AOP(IC_RIGHT(ic))->aopu.aop_dir,
-                  AOP(IC_RIGHT(ic))->aopu.aop_dir);
-         pic14_emitcode(" incf","%s,f", aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+      if(lit & 0xff) {
+       emitpcode(POC_MOVLW, popGetLit(lit & 0xff));
+       emitpcode(POC_ADDFW, popGet(AOP(left),0,FALSE,FALSE));
+      } else
+       emitpcode(POC_MOVFW, popGet(AOP(left),0,FALSE,FALSE));
+
+      emitpcode(POC_MOVWF, popGet(AOP(result),0,FALSE,FALSE));
+      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));
+         emitSKPNC;
+         emitpcode(POC_INCFSZW,popGet(AOP(left),offset,FALSE,FALSE));
+         emitpcode(POC_ADDWF,  popGet(AOP(result),offset,FALSE,FALSE));
        } 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));
+       }
+      offset++;
+      }
+    }
+  }
+}
 
-         if(AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) {
-           emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
-           emitpcode(POC_XORLW , popGetLit(1));
+/*-----------------------------------------------------------------*/
+/* genPlus - generates code for addition                           */
+/*-----------------------------------------------------------------*/
+void genPlus (iCode *ic)
+{
+  int size, offset = 0;
 
-           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");
-         } 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));
+  /* special cases :- */
+  DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+
+  aopOp (IC_LEFT(ic),ic,FALSE);
+  aopOp (IC_RIGHT(ic),ic,FALSE);
+  aopOp (IC_RESULT(ic),ic,TRUE);
+
+  /* if literal, literal on the right or
+     if left requires ACC or right is already
+     in ACC */
+
+  if (AOP_TYPE(IC_LEFT(ic)) == AOP_LIT) {
+    operand *t = IC_RIGHT(ic);
+    IC_RIGHT(ic) = IC_LEFT(ic);
+    IC_LEFT(ic) = t;
+  }
+
+  /* if both left & right are in bit space */
+  if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY &&
+      AOP_TYPE(IC_RIGHT(ic)) == AOP_CRY) {
+    genPlusBits (ic);
+    goto release ;
+  }
+
+  /* if left in bit space & right literal */
+  if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY &&
+      AOP_TYPE(IC_RIGHT(ic)) == AOP_LIT) {
+    /* if result in bit space */
+    if(AOP_TYPE(IC_RESULT(ic)) == AOP_CRY){
+      if((unsigned long)floatFromVal(AOP(IC_RIGHT(ic))->aopu.aop_lit) != 0L) {
+       emitpcode(POC_MOVLW, popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+       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));
+      }
+    } else {
+      size = pic14_getDataSize(IC_RESULT(ic));
+      while (size--) {
+       MOVA(aopGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));  
+       pic14_emitcode("addc","a,#00  ;%d",__LINE__);
+       aopPut(AOP(IC_RESULT(ic)),"a",offset++);
+      }
+    }
+    goto release ;
+  }
+
+  /* if I can do an increment instead
+     of add then GOOD for ME */
+  if (genPlusIncr (ic) == TRUE)
+    goto release;   
+
+  size = pic14_getDataSize(IC_RESULT(ic));
+
+  if(AOP(IC_RIGHT(ic))->type == AOP_LIT) {
+    /* Add a literal to something else */
+    //bool know_W=0;
+    unsigned lit = (unsigned) floatFromVal(AOP(IC_RIGHT(ic))->aopu.aop_lit);
+    //      unsigned l1=0;
+
+    //      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);
 
-           pic14_emitcode("movf","%s,w", aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
-           pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
-                    AOP(IC_RIGHT(ic))->aopu.aop_dir,
-                    AOP(IC_RIGHT(ic))->aopu.aop_dir);
-           pic14_emitcode(" incf","%s,w", aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+      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));
          }
-         
-         if(AOP_TYPE(IC_RESULT(ic)) != AOP_ACC) {
-           
-           if(AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) {
-             emitpcode(POC_ANDLW , popGetLit(1));
-             emitpcode(POC_BCF ,   popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
-             emitSKPZ;
-             emitpcode(POC_BSF ,   popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
-           } else {
-             emitpcode(POC_MOVWF ,   popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
-             pic14_emitcode("movwf","%s", aopGet(AOP(IC_RESULT(ic)),0,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));
          }
        }
+      }
 
-      } else {
-       int offset = 1;
+      l1 = lit & 0xff;
+      lit >>= 8;
+      offset++;
+    }
+#endif
 
-       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));
+  } else if(AOP_TYPE(IC_RIGHT(ic)) == AOP_CRY) {
 
-         pic14_emitcode("clrz","");
+    pic14_emitcode(";bitadd","right is bit: %s",aopGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+    pic14_emitcode(";bitadd","left is bit: %s",aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+    pic14_emitcode(";bitadd","result is bit: %s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
 
-         pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
-                  AOP(IC_RIGHT(ic))->aopu.aop_dir,
-                  AOP(IC_RIGHT(ic))->aopu.aop_dir);
-         pic14_emitcode(" incf","%s,f", aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+    /* here we are adding a bit to a char or int */
+    if(size == 1) {
+      if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) ) {
 
-       } else {
+       emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+       emitpcode(POC_INCF ,  popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
 
-         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));
+       pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
+                      AOP(IC_RIGHT(ic))->aopu.aop_dir,
+                      AOP(IC_RIGHT(ic))->aopu.aop_dir);
+       pic14_emitcode(" incf","%s,f", aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+      } else {
+
+       if(AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) {
+         emitpcode(POC_BTFSC , popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+         emitpcode(POC_XORLW , popGetLit(1));
 
+         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");
+       } 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));
 
          pic14_emitcode("movf","%s,w", aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
          pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
-                  AOP(IC_RIGHT(ic))->aopu.aop_dir,
-                  AOP(IC_RIGHT(ic))->aopu.aop_dir);
+                        AOP(IC_RIGHT(ic))->aopu.aop_dir,
+                        AOP(IC_RIGHT(ic))->aopu.aop_dir);
          pic14_emitcode(" incf","%s,w", aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
-         pic14_emitcode("movwf","%s", aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
-
        }
-
-       while(--size){
-         emitSKPZ;
-         emitpcode(POC_INCF,  popGet(AOP(IC_RESULT(ic)),offset++,FALSE,FALSE));
-      //pic14_emitcode(" incf","%s,f", aopGet(AOP(IC_RIGHT(ic)),offset++,FALSE,FALSE));
+         
+       if(AOP_TYPE(IC_RESULT(ic)) != AOP_ACC) {
+           
+         if(AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) {
+           emitpcode(POC_ANDLW , popGetLit(1));
+           emitpcode(POC_BCF ,   popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+           emitSKPZ;
+           emitpcode(POC_BSF ,   popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+         } else {
+           emitpcode(POC_MOVWF ,   popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+           pic14_emitcode("movwf","%s", aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+         }
        }
+      }
+
+    } else {
+      int offset = 1;
+
+      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));
+
+       pic14_emitcode("clrz","");
 
+       pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
+                      AOP(IC_RIGHT(ic))->aopu.aop_dir,
+                      AOP(IC_RIGHT(ic))->aopu.aop_dir);
+       pic14_emitcode(" incf","%s,f", aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+
+      } 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));
+
+
+       pic14_emitcode("movf","%s,w", aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+       pic14_emitcode("btfsc","(%s >> 3), (%s & 7)",
+                      AOP(IC_RIGHT(ic))->aopu.aop_dir,
+                      AOP(IC_RIGHT(ic))->aopu.aop_dir);
+       pic14_emitcode(" incf","%s,w", aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+       pic14_emitcode("movwf","%s", aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+
+      }
+
+      while(--size){
+       emitSKPZ;
+       emitpcode(POC_INCF,  popGet(AOP(IC_RESULT(ic)),offset++,FALSE,FALSE));
+       //pic14_emitcode(" incf","%s,f", aopGet(AOP(IC_RIGHT(ic)),offset++,FALSE,FALSE));
       }
+
+    }
       
-    } else {
+  } else {
     
-      if(strcmp(aopGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE),"a") == 0 ) {
+    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));
+    } else {
+
+      if ( AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) {
        emitpcode(POC_ADDFW, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
-       emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
+       if ( AOP_TYPE(IC_RESULT(ic)) != AOP_ACC)
+         emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
       } else {
 
-       if ( AOP_TYPE(IC_LEFT(ic)) == AOP_ACC) {
-         emitpcode(POC_ADDFW, popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
-         if ( AOP_TYPE(IC_RESULT(ic)) != AOP_ACC)
-           emitpcode(POC_MOVWF,popGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE));
-       } else {
-
-         emitpcode(POC_MOVFW,popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
+       emitpcode(POC_MOVFW,popGet(AOP(IC_RIGHT(ic)),0,FALSE,FALSE));
 
-         if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) )
-           emitpcode(POC_ADDWF, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
-         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));
-           }
+       if (pic14_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) )
+         emitpcode(POC_ADDWF, popGet(AOP(IC_LEFT(ic)),0,FALSE,FALSE));
+       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));
          }
        }
       }
+    }
 
-      offset = 1;
-      size--;
+    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));
+    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));
 
-         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));
-       }
+       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));
-       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_MOVFW,   popGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));
+      emitSKPNC;
+      emitpcode(POC_INCFSZW, popGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));
+      emitpcode(POC_ADDWF,   popGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
 
-       /*
+      /*
        pic14_emitcode("movf","%s,w",  aopGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));
        emitSKPNC;
        pic14_emitcode("incfsz","%s,w",aopGet(AOP(IC_RIGHT(ic)),offset,FALSE,FALSE));
        pic14_emitcode("addwf","%s,f", aopGet(AOP(IC_RESULT(ic)),offset,FALSE,FALSE));
-       */
-
-       offset++;
-      }
+      */
 
+      offset++;
     }
 
-    //adjustArithmeticResult(ic);
+  }
+
+  //adjustArithmeticResult(ic);
 
  release:
-      freeAsmop(IC_LEFT(ic),NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
-      freeAsmop(IC_RIGHT(ic),NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
-      freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
+  freeAsmop(IC_LEFT(ic),NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+  freeAsmop(IC_RIGHT(ic),NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
+  freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
 }
 
 /*-----------------------------------------------------------------*/
@@ -619,6 +835,7 @@ bool genMinusDec (iCode *ic)
       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));
 
        pic14_emitcode("decf","%s,f",aopGet(AOP(IC_RESULT(ic)),LSB,FALSE,FALSE));
@@ -765,8 +982,8 @@ void genMinus (iCode *ic)
 
   /* if I can do an decrement instead
      of subtract then GOOD for ME */
-  if (genMinusDec (ic) == TRUE)
-    goto release;   
+  //  if (genMinusDec (ic) == TRUE)
+  //    goto release;   
 
   size = pic14_getDataSize(IC_RESULT(ic));   
 
@@ -776,6 +993,9 @@ 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);
+    
+#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));
@@ -811,7 +1031,7 @@ void genMinus (iCode *ic)
       }
       offset++;
     }
-
+#endif
   } else if(AOP_TYPE(IC_RIGHT(ic)) == AOP_CRY) {
     // bit subtraction
 

diff --git a/src/regression/Makefile b/src/regression/Makefile
index a2bd9a2a1983ee2ed58160b51db1d5a0382da337..680eaf76c91a29830826968b2de62495220cefb4 100644 (file)
--- a/src/regression/Makefile
+++ b/src/regression/Makefile
@@ -56,6 +56,7 @@ SIMULATE = simulate
 # List the C files to be test here:
 SRC = b.c \
        add.c \
+       add2.c \
        bool1.c \
        call1.c \
        compare.c \

diff --git a/src/regression/add2.c b/src/regression/add2.c
new file mode 100644 (file)
index 0000000..020ed2d
--- /dev/null
+++ b/src/regression/add2.c
@@ -0,0 +1,304 @@
+
+// Addition tests - mostly int's
+
+/* bit types are not ANSI - so provide a way of disabling bit types
+ * if this file is used to test other compilers besides SDCC */
+#define SUPPORT_BIT_TYPES 1
+
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned int aint2 = 0;
+unsigned int aint3 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char achar2 = 0;
+unsigned char achar3 = 0;
+unsigned char *acharP = 0;
+
+#if SUPPORT_BIT_TYPES
+
+bit bit0 = 0;
+bit bit1 = 0;
+bit bit2 = 0;
+bit bit3 = 0;
+bit bit4 = 0;
+bit bit5 = 0;
+bit bit6 = 0;
+bit bit7 = 0;
+bit bit8 = 0;
+bit bit9 = 0;
+bit bit10 = 0;
+bit bit11 = 0;
+
+#endif
+
+
+void done()
+{
+
+  dummy++;
+
+}
+
+void add_lit2uint(void)
+{
+
+  aint0 = aint0 + 5;
+
+  if(aint0 != 5)
+    failures++;
+
+  aint0 += 10;
+
+  if(aint0 != 15)
+    failures++;
+
+  aint0 = aint0 +1;  // Should be an increment
+  if(aint0 != 16)
+    failures++;
+
+  for(aint1 = 0; aint1 < 100; aint1++)
+    aint0 += 2;
+
+  if(aint0 != 216)
+    failures++;
+
+}
+
+void add_uint2uint (void)
+{
+
+  aint1 = aint1 + aint0;
+
+  if(aint1 != 16)
+    failures++;
+
+  for(aint2 = 0; aint2<7; aint2++)
+    aint1 += aint0;
+
+  if(aint1 != 128)
+    failures++;
+
+}
+
+// assumes
+//  aint0 = 0
+//  aint1 = 32
+//  aint2, aint3 can be anything.
+
+void add_uint2uint2(void)
+{
+
+
+  aint0++;
+  aint0 = aint0 + 1;
+  aint0 = aint0 + 2;
+  aint0 = aint0 + 3;
+  if(aint0 != 7)
+    failures++;
+
+  aint1 += aint0;
+  if(aint1 != 39)
+    failures++;
+
+  aint2 = aint1 + aint0;
+  if(aint2 != 46)
+    failures++;
+
+  aint3 = aint2 + aint1 + aint0;
+  if(aint3 != 92)
+    failures++;
+
+}
+
+#if SUPPORT_BIT_TYPES
+void add_bits(void)
+{
+
+  bit1 = bit0;
+
+  bit0 = 1;
+
+  if(bit1 != 0)
+    failures++;
+
+  bit1 = bit1+bit0;
+  if(bit1 != 1)
+    failures++;
+
+  bit2 = bit1+bit3;
+  if(!bit2)
+    failures++;
+
+  bit3 = bit4+bit5+bit6+bit7+bit0;
+  if(!bit3)
+    failures++;
+}
+#endif
+
+/* add_bit2uchar(void) - assumes bit0 = 1, aint0 = 7  */
+
+void add_bit2uchar(void)
+{
+
+  achar0 += bit0;
+
+  if(achar0 != 8)
+    failures++;
+
+  if(achar0 == bit0)
+    failures++;
+
+}
+
+void add_bit2uint(void)
+{
+
+  if(aint0 != bit11)
+    failures++;
+
+  aint0 += bit0;
+  if(aint0!=1)
+    failures++;
+
+}
+
+/***********************************/
+
+void addlits(void)
+{
+  aint0 += 0x0001;
+
+  if(aint0 != 1)
+    failures++;
+
+  aint0 += 0x00;
+
+  if(aint0 != 1)
+    failures++;
+
+  aint0 += 0x00fe;
+  if(aint0 != 0x00ff)
+    failures++;
+
+  aint0 += 0x0001;
+
+  if(aint0 != 0x0100)
+    failures++;
+
+  aint0++;
+  if(aint0 != 0x0101)
+    failures++;
+
+  aint0 += 0x00ff;
+  if(aint0 != 0x0200)
+    failures++;
+
+  aint0 += 0x00a0;
+  if(aint0 != 0x02a0)
+    failures++;
+
+  aint0 += 0x0061;
+  if(aint0 != 0x0301)
+    failures++;
+
+  aint0 += 0x0100;
+  if(aint0 != 0x0401)
+    failures++;
+
+  aint0 += 0x0101;
+  if(aint0 != 0x0502)
+    failures++;
+
+  aint0 += 0x00fd;
+  if(aint0 != 0x05ff)
+    failures++;
+
+  aint0 += 0x0101;
+  if(aint0 != 0x0700)
+    failures++;
+
+  aint0 += 0x01ff;
+  if(aint0 != 0x08ff)
+    failures++;
+
+  aint0 += 0x01ff;
+  if(aint0 != 0x0afe)
+    failures++;
+
+  aint0 += 0xff02;
+  if(aint0 != 0x0a00)
+    failures++;
+
+  aint0 += 0xffff;
+  if(aint0 != 0x09ff)
+    failures++;
+
+  aint0 += 0xff01;
+  if(aint0 != 0x0900)
+    failures++;
+
+  aint0 += 0xff00;
+  if(aint0 != 0x0800)
+    failures++;
+
+  aint0 += 0xff01;
+  if(aint0 != 0x0701)
+    failures++;
+
+  aint0 += 0x0300;
+  if(aint0 != 0x0a01)
+    failures++;
+
+  aint0 += 0x03ff;
+  if(aint0 != 0x0e00)
+    failures++;
+
+  aint0 += 0x0301;
+  if(aint0 != 0x1101)
+    failures++;
+
+  aint0 += 0x03fe;
+  if(aint0 != 0x14ff)
+    failures++;
+
+  aint0 += 0x0301;
+  if(aint0 != 0x1800)
+    failures++;
+ 
+}
+
+
+void main(void)
+{
+
+  add_lit2uint();
+
+  aint0=16;
+  aint1=0;
+  //  add_uint2uint();
+
+
+  aint0 = 0;
+  aint1 = 32;
+  //  add_uint2uint2();
+
+#if SUPPORT_BIT_TYPES
+  //  add_bits();
+
+  //  add_bit2uchar();
+  //  add_bit2uint();
+#endif
+
+  aint0 = 0;
+  addlits();
+
+  success = failures;
+  done();
+}

diff --git a/src/regression/compare3.c b/src/regression/compare3.c
index 4cc21613545168f86dbb628f7f32a08f9f0c61e2..6aa173e90edd7d9625a08d3f983551899bfe3473 100644 (file)
--- a/src/regression/compare3.c
+++ b/src/regression/compare3.c
@@ -185,6 +185,18 @@ void c_abcd(void)
   if(aint0 == 0x00cd)
     failures++;
 
+  if(aint0 == 0x05cd)
+    failures++;
+
+  if(aint0 == 0xab05)
+    failures++;
+
+  if(aint0 == 0xab01)
+    failures++;
+
+  if(aint0 == 0x01cd)
+    failures++;
+
   if(aint0 == 0x1234abcd)
     failures++;