git.gag.com Git - fw/sdcc/blob - support/regression/tests/onebyte.c

   1 /** test one byte mul/div/mod operations.
   2
   3   attrL: volatile,
   4   attrR: volatile,
   5 */
   6 #include <testfwk.h>
   7
   8 void
   9 testMul(void)
  10 {
  11 #ifndef SDCC_pic16  /* bug [ 1444425 ] onebyte.c regression tes fails on pic16 */
  12   {attrL}            char  cL;
  13   {attrL}  unsigned  char ucL;
  14   {attrR}            char  cR;
  15   {attrR}  unsigned  char ucR;
  16   volatile           char   r8 , r8b;
  17   volatile unsigned  char  ur8, ur8b;
  18   volatile           short r16, r16b;
  19
  20   cL = -127; cR =   -5; r16 =  cL * cR; r16b = cR *  cL; ASSERT(r16 ==  635); ASSERT(r16b ==  635);
  21   cL =  127; cR =   -5; r16 =  cL * cR; r16b = cR *  cL; ASSERT(r16 == -635); ASSERT(r16b == -635);
  22   cL = -127; cR =    5; r16 =  cL * cR; r16b = cR *  cL; ASSERT(r16 == -635); ASSERT(r16b == -635);
  23   cL =  127; cR =    5; r16 =  cL * cR; r16b = cR *  cL; ASSERT(r16 ==  635); ASSERT(r16b ==  635);
  24
  25   cL = -128; cR =   -1; ur8  =  cL * cR; ur8b  = cR *  cL; ASSERT(ur8  ==  128); ASSERT(ur8b  ==  128);
  26   cL =  128; cR =   -1;  r8  =  cL * cR;  r8b  = cR *  cL; ASSERT( r8  == -128); ASSERT( r8b  == -128);
  27   cL = -128; cR =    1;  r8  =  cL * cR;  r8b  = cR *  cL; ASSERT( r8  == -128); ASSERT( r8b  == -128);
  28   cL =  128; cR =    1; ur8  =  cL * cR; ur8b  = cR *  cL; ASSERT(ur8  ==  128); ASSERT(ur8b  ==  128);
  29
  30 #ifndef SDCC_z80
  31   ucL = 128; cR =   -5; r16 = ucL * cR; r16b = cR * ucL; ASSERT(r16 == -640); ASSERT(r16b == -640);
  32   ucL = 128; cR =    5; r16 = ucL * cR; r16b = cR * ucL; ASSERT(r16 ==  640); ASSERT(r16b ==  640);
  33 #endif
  34
  35   ucL = 127;  cR =  -1;  r8 = ucL * cR;   r8b  = cR * ucL; ASSERT( r8 == -127); ASSERT( r8b  == -127);
  36   ucL = 128;  cR =   1; ur8 = ucL * cR;  ur8b  = cR * ucL; ASSERT(ur8 ==  128); ASSERT(ur8b  ==  128);
  37   ucL = 128; ucR =   5; r16 = ucL * ucR; r16b = ucR * ucL; ASSERT(r16 ==  640); ASSERT(r16b ==  640);
  38   ucL = 128; ucR =   1; ur8 = ucL * ucR; ur8b = ucR * ucL; ASSERT(ur8 ==  128); ASSERT(ur8b ==  128);
  39 #endif
  40 }
  41
  42 void
  43 testDiv(void)
  44 {
  45   {attrL}           char  cL;
  46   {attrL}  unsigned char ucL;
  47   {attrR}           char  cR;
  48   {attrR}  unsigned char ucR;
  49   volatile          char  r8;
  50   volatile unsigned char ur8;
  51   volatile         short r16;
  52
  53    cL = -128;  cR =   -2; r8  = cL / cR; ASSERT(r8  ==  64);
  54    cL = -128;  cR =   -2; r16 = cL / cR; ASSERT(r16 ==  64);
  55
  56   ucL =  255; ucR =    3; r8 = ucL / ucR; ASSERT(r8 ==  85);
  57   ucL =  255; ucR =  255; r8 = ucL / ucR; ASSERT(r8 ==   1);
  58   ucL =    3; ucR =  255; r8 = ucL / ucR; ASSERT(r8 ==   0);
  59
  60    cL =  127;  cR =    3; r8 =  cL /  cR; ASSERT(r8 ==  42);
  61    cL = -127;  cR =    3; r8 =  cL /  cR; ASSERT(r8 == -42);
  62    cL =  127;  cR =   -3; r8 =  cL /  cR; ASSERT(r8 == -42);
  63    cL = -127;  cR =   -3; r8 =  cL /  cR; ASSERT(r8 ==  42);
  64
  65   ucL =  127;  cR =    3; r8 = ucL /  cR; ASSERT(r8 ==  42);
  66   ucL =  255;  cR =    3; r8 = ucL /  cR; ASSERT(r8 ==  85);
  67 #ifndef SDCC_z80
  68   ucL =  127;  cR =   -3; r8 = ucL /  cR; ASSERT(r8 == -42);
  69   ucL =  255;  cR =   -3; r8 = ucL /  cR; ASSERT(r8 == -85);
  70 #endif
  71
  72    cL =  127; ucR =    3; r8 =  cL / ucR; ASSERT(r8 ==  42);
  73    cL = -127; ucR =    3; r8 =  cL / ucR; ASSERT(r8 == -42);
  74    cL =  127; ucR =  128; r8 =  cL / ucR; ASSERT(r8 ==   0);
  75    cL = -127; ucR =  128; r8 =  cL / ucR; ASSERT(r8 ==   0);
  76
  77    cL =  127;  cR =    1; r8  =  cL /  cR; ASSERT(r8  == 127);
  78    cL =  127;  cR =    1; r16 =  cL /  cR; ASSERT(r16 == 127);
  79
  80   ucL = 251;   cR =    1; ur8 = ucL /  cR; ASSERT(ur8 == 251);
  81   ucL = 251;   cR =    1; r16 = ucL /  cR; ASSERT(r16 == 251);
  82
  83 #ifndef SDCC_z80
  84   ucL = 253;   cR =   -3; r8  = ucL /  cR; ASSERT(r8  == -84);
  85   ucL = 253;   cR =   -3; r16 = ucL /  cR; ASSERT(r16 == -84);
  86
  87   ucL =  254;  cR =   -1; r16 = ucL /  cR; ASSERT(r16 == -254);
  88 #endif
  89    cL = -128;  cR =   -1; r16 =  cL /  cR; ASSERT(r16 ==  128);
  90 }
  91
  92 void
  93 testMod(void)
  94 {
  95   {attrL}           char  cL;
  96   {attrL}  unsigned char ucL;
  97   {attrR}           char  cR;
  98   {attrR}  unsigned char ucR;
  99   volatile          char  r8;
 100   volatile unsigned char ur8;
 101   volatile         short r16;
 102
 103   ucL =  128;  cR =    5; r16 = ucL %  cR; ASSERT(r16 ==  3);
 104 #ifndef SDCC_z80
 105   ucL =  128;  cR =   -5; r16 = ucL %  cR; ASSERT(r16 ==  3);
 106 #endif
 107   ucL =  128; ucR =    5; r16 = ucL % ucR; ASSERT(r16 ==  3);
 108
 109   ucL =  128; ucR =  255; ur8 = ucL % ucR; ASSERT(ur8 == 128);
 110   ucL =  128; ucR =  255; r16 = ucL % ucR; ASSERT(r16 == 128);
 111
 112   ucL =  128;  cR =  127; r8  = ucL %  cR; ASSERT(r8  ==  1);
 113
 114    cL =  127;  cR =    5; r16 =  cL %  cR; ASSERT(r16 ==  2);
 115    r16 = -1;
 116    cL =  127;  cR =   -5; r16 =  cL %  cR; ASSERT(r16 ==  2);
 117    r16 = -1;
 118    cL =  127; ucR =    5; r16 =  cL % ucR; ASSERT(r16 ==  2);
 119
 120    cL = -128;  cR =    5; r16 =  cL %  cR; ASSERT(r16 == -3);
 121    r16 = 0;
 122    cL = -128;  cR =   -5; r16 =  cL %  cR; ASSERT(r16 == -3);
 123    r16 = 0;
 124    cL = -128; ucR =    5; r16 =  cL % ucR; ASSERT(r16 == -3);
 125 }
 126
 127 void
 128 testOr(void)
 129 {
 130   {attrL}           char  cL;
 131   {attrL}  unsigned char ucL;
 132   {attrR}           char  cR;
 133   {attrR}  unsigned char ucR;
 134   volatile         short r16, r16b;
 135
 136    cL = 0x00;  cR = 0x80; r16 =  cL |  cR; r16b =  cR |  cL; ASSERT(r16 == (short) 0xff80); ASSERT(r16b == (short) 0xff80);
 137   ucL = 0x80;  cR = 0x00; r16 = ucL |  cR; r16b =  cR | ucL; ASSERT(r16 ==           0x80); ASSERT(r16b ==           0x80);
 138   ucL = 0x80; ucR = 0x80; r16 = ucL | ucR; r16b = ucR | ucL; ASSERT(r16 ==           0x80); ASSERT(r16b ==           0x80);
 139 }
 140
 141 void
 142 testXor(void)
 143 {
 144   {attrL}           char  cL;
 145   {attrL}  unsigned char ucL;
 146   {attrR}           char  cR;
 147   {attrR}  unsigned char ucR;
 148   volatile         short r16, r16b;
 149
 150    cL = 0x80;  cR = 0x80; r16 =  cL ^  cR; r16b =  cR ^  cL; ASSERT(r16 ==              0); ASSERT(r16b ==              0);
 151    cL = 0x80;  cR = 0x00; r16 =  cL ^  cR; r16b =  cR ^  cL; ASSERT(r16 == (short) 0xff80); ASSERT(r16b == (short) 0xff80);
 152
 153   ucL = 0x80;  cR = 0x80; r16 = ucL ^  cR; r16b =  cR ^ ucL; ASSERT(r16 == (short) 0xff00); ASSERT(r16b == (short) 0xff00);
 154   ucL = 0x80;  cR =    0; r16 = ucL ^  cR; r16b =  cR ^ ucL; ASSERT(r16 ==           0x80); ASSERT(r16b ==           0x80);
 155   ucL =    0;  cR = 0x80; r16 = ucL ^  cR; r16b =  cR ^ ucL; ASSERT(r16 == (short) 0xff80); ASSERT(r16b == (short) 0xff80);
 156
 157   ucL = 0x80; ucR = 0x80; r16 = ucL ^ ucR; r16b = ucR ^ ucL; ASSERT(r16 ==      0); ASSERT(r16b ==      0);
 158   ucL =    0; ucR = 0x80; r16 = ucL ^ ucR; r16b = ucR ^ ucL; ASSERT(r16 ==   0x80); ASSERT(r16b ==   0x80);
 159 }
 160
 161 void
 162 testAnd(void)
 163 {
 164   {attrL}           char  cL;
 165   {attrL}  unsigned char ucL;
 166   {attrR}           char  cR;
 167   {attrR}  unsigned char ucR;
 168   volatile         short r16, r16b;
 169
 170    cL = 0x80;  cR = 0x80; r16 =  cL &  cR; r16b =  cR &  cL; ASSERT(r16 == (short) 0xff80); ASSERT(r16b == (short) 0xff80);
 171   ucL = 0x80;  cR = 0x80; r16 = ucL &  cR; r16b =  cR & ucL; ASSERT(r16 ==           0x80); ASSERT(r16b ==           0x80);
 172   ucL = 0x80; ucR = 0x80; r16 = ucL & ucR; r16b = ucR & ucL; ASSERT(r16 ==           0x80); ASSERT(r16b ==           0x80);
 173 }
 174
 175 void
 176 testComplement(void)
 177 {
 178   {attrR}           char  c;
 179   {attrR}  unsigned char uc;
 180   volatile         short r16;
 181
 182    c = 0x00;  r16 = ~ c; ASSERT(r16    == (short) 0xffff); ASSERT(  ~ c < 0);
 183   uc = 0x00;  r16 = ~uc; ASSERT(r16    == (short) 0xffff); ASSERT(  ~uc < 0);
 184   ASSERT(~ (char)          0x00 == (short) 0xffff); ASSERT(~ (char)          0x00 < 0);
 185   ASSERT(~ (unsigned char) 0x00 == (short) 0xffff); ASSERT(~ (unsigned char) 0x00 < 0);
 186    c = 0x80;  r16 = ~ c; ASSERT(r16 == (short) 0x007f); ASSERT(~ c > 0);
 187   uc = 0x80;  r16 = ~uc; ASSERT(r16 == (short) 0xff7f); ASSERT(~uc < 0);
 188   ASSERT(~ (char)          0x80 == (short) 0x007f); ASSERT(~ (char)          0x80 > 0);
 189   ASSERT(~ (unsigned char) 0x80 == (short) 0xff7f); ASSERT(~ (unsigned char) 0x80 < 0);
 190
 191   ASSERT(~ 1   < 0);
 192   ASSERT(~ 1u  > 0);
 193   ASSERT(~ 1l  < 0);
 194   ASSERT(~ 1ul > 0);
 195 }
 196
 197 void
 198 testCompare(void)
 199 {
 200   {attrL}   signed char  c;
 201   {attrR} unsigned char uc;
 202
 203    c = 0x80; /* -128 */
 204   uc = 0x80; /* +128 */
 205
 206   ASSERT(!(c == uc));
 207   ASSERT(  c != uc );
 208   ASSERT(  c <  uc );
 209   ASSERT(  c <= uc );
 210   ASSERT(!(c >  uc));
 211   ASSERT(!(c >= uc));
 212 }
 213
 214 void
 215 testUMinus(void)
 216 {
 217     signed char  {attrL} sc;
 218   unsigned char  {attrL} uc;
 219     signed int   {attrL} si;
 220   unsigned int   {attrL} ui;
 221     signed long  {attrL} sl;
 222   unsigned long  {attrL} ul;
 223
 224   ASSERT(-(53l ) < 0);
 225   ASSERT(-(53ul) > 0);
 226   ul = 53;
 227   ASSERT(-ul > 0);
 228   sl = 53;
 229   ASSERT(-sl < 0);
 230
 231   ASSERT(-(53  ) < 0);
 232   ASSERT(-(53u ) > 0);
 233   ui = 53;
 234   ASSERT(-ui > 0);
 235   si = 53;
 236   ASSERT(-si < 0);
 237
 238   ASSERT(-( 250 ) == -250);
 239   uc = 250;
 240   ASSERT(-uc == -250);
 241
 242   ASSERT(-(-128 ) ==  128);
 243   sc = -128;
 244   ASSERT(-sc == 128);
 245 }
 246
 247 void
 248 testBug1571231(void)
 249 {
 250   unsigned char  {attrL} uc;
 251
 252   /* bug-1571231 */
 253   uc = 0x80;
 254   if (uc + 0x80)
 255     ASSERT(1);
 256   else
 257     ASSERT(0);
 258 }