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   {attrL}            char  cL;
  12   {attrL}  unsigned  char ucL;
  13   {attrR}            char  cR;
  14   {attrR}  unsigned  char ucR;
  15   volatile           char   r8 , r8b;
  16   volatile unsigned  char  ur8, ur8b;
  17   volatile           short r16, r16b;
  18
  19   cL = -127; cR =   -5; r16 =  cL * cR; r16b = cR *  cL; ASSERT(r16 ==  635); ASSERT(r16b ==  635);
  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
  24   cL = -128; cR =   -1; ur8  =  cL * cR; ur8b  = cR *  cL; ASSERT(ur8  ==  128); ASSERT(ur8b  ==  128);
  25   cL =  128; cR =   -1;  r8  =  cL * cR;  r8b  = cR *  cL; ASSERT( r8  == -128); ASSERT( r8b  == -128);
  26   cL = -128; cR =    1;  r8  =  cL * cR;  r8b  = cR *  cL; ASSERT( r8  == -128); ASSERT( r8b  == -128);
  27   cL =  128; cR =    1; ur8  =  cL * cR; ur8b  = cR *  cL; ASSERT(ur8  ==  128); ASSERT(ur8b  ==  128);
  28
  29 #ifndef SDCC_z80
  30   ucL = 128; cR =   -5; r16 = ucL * cR; r16b = cR * ucL; ASSERT(r16 == -640); ASSERT(r16b == -640);
  31   ucL = 128; cR =    5; r16 = ucL * cR; r16b = cR * ucL; ASSERT(r16 ==  640); ASSERT(r16b ==  640);
  32 #endif
  33
  34   ucL = 127;  cR =  -1;  r8 = ucL * cR;   r8b  = cR * ucL; ASSERT( r8 == -127); ASSERT( r8b  == -127);
  35   ucL = 128;  cR =   1; ur8 = ucL * cR;  ur8b  = cR * ucL; ASSERT(ur8 ==  128); ASSERT(ur8b  ==  128);
  36   ucL = 128; ucR =   5; r16 = ucL * ucR; r16b = ucR * ucL; ASSERT(r16 ==  640); ASSERT(r16b ==  640);
  37   ucL = 128; ucR =   1; ur8 = ucL * ucR; ur8b = ucR * ucL; ASSERT(ur8 ==  128); ASSERT(ur8b ==  128);
  38 }
  39
  40 void
  41 testDiv(void)
  42 {
  43   {attrL}           char  cL;
  44   {attrL}  unsigned char ucL;
  45   {attrR}           char  cR;
  46   {attrR}  unsigned char ucR;
  47   volatile          char  r8;
  48   volatile unsigned char ur8;
  49   volatile         short r16;
  50
  51    cL = -128;  cR =   -2; r8  = cL / cR; ASSERT(r8  ==  64);
  52    cL = -128;  cR =   -2; r16 = cL / cR; ASSERT(r16 ==  64);
  53
  54   ucL =  255; ucR =    3; r8 = ucL / ucR; ASSERT(r8 ==  85);
  55   ucL =  255; ucR =  255; r8 = ucL / ucR; ASSERT(r8 ==   1);
  56   ucL =    3; ucR =  255; r8 = ucL / ucR; ASSERT(r8 ==   0);
  57
  58    cL =  127;  cR =    3; r8 =  cL /  cR; ASSERT(r8 ==  42);
  59    cL = -127;  cR =    3; r8 =  cL /  cR; ASSERT(r8 == -42);
  60    cL =  127;  cR =   -3; r8 =  cL /  cR; ASSERT(r8 == -42);
  61    cL = -127;  cR =   -3; r8 =  cL /  cR; ASSERT(r8 ==  42);
  62
  63   ucL =  127;  cR =    3; r8 = ucL /  cR; ASSERT(r8 ==  42);
  64   ucL =  255;  cR =    3; r8 = ucL /  cR; ASSERT(r8 ==  85);
  65 #ifndef SDCC_z80
  66   ucL =  127;  cR =   -3; r8 = ucL /  cR; ASSERT(r8 == -42);
  67   ucL =  255;  cR =   -3; r8 = ucL /  cR; ASSERT(r8 == -85);
  68 #endif
  69
  70    cL =  127; ucR =    3; r8 =  cL / ucR; ASSERT(r8 ==  42);
  71    cL = -127; ucR =    3; r8 =  cL / ucR; ASSERT(r8 == -42);
  72    cL =  127; ucR =  128; r8 =  cL / ucR; ASSERT(r8 ==   0);
  73    cL = -127; ucR =  128; r8 =  cL / ucR; ASSERT(r8 ==   0);
  74
  75    cL =  127;  cR =    1; r8  =  cL /  cR; ASSERT(r8  == 127);
  76    cL =  127;  cR =    1; r16 =  cL /  cR; ASSERT(r16 == 127);
  77
  78   ucL = 251;   cR =    1; ur8 = ucL /  cR; ASSERT(ur8 == 251);
  79   ucL = 251;   cR =    1; r16 = ucL /  cR; ASSERT(r16 == 251);
  80
  81 #ifndef SDCC_z80
  82   ucL = 253;   cR =   -3; r8  = ucL /  cR; ASSERT(r8  == -84);
  83   ucL = 253;   cR =   -3; r16 = ucL /  cR; ASSERT(r16 == -84);
  84
  85   ucL =  254;  cR =   -1; r16 = ucL /  cR; ASSERT(r16 == -254);
  86 #endif
  87    cL = -128;  cR =   -1; r16 =  cL /  cR; ASSERT(r16 ==  128);
  88 }
  89
  90 void
  91 testMod(void)
  92 {
  93   {attrL}           char  cL;
  94   {attrL}  unsigned char ucL;
  95   {attrR}           char  cR;
  96   {attrR}  unsigned char ucR;
  97   volatile          char  r8;
  98   volatile unsigned char ur8;
  99   volatile         short r16;
 100
 101   ucL =  128;  cR =    5; r16 = ucL %  cR; ASSERT(r16 ==  3);
 102 #ifndef SDCC_z80
 103   ucL =  128;  cR =   -5; r16 = ucL %  cR; ASSERT(r16 ==  3);
 104 #endif
 105   ucL =  128; ucR =    5; r16 = ucL % ucR; ASSERT(r16 ==  3);
 106
 107   ucL =  128; ucR =  255; ur8 = ucL % ucR; ASSERT(ur8 == 128);
 108   ucL =  128; ucR =  255; r16 = ucL % ucR; ASSERT(r16 == 128);
 109
 110   ucL =  128;  cR =  127; r8  = ucL %  cR; ASSERT(r8  ==  1);
 111
 112    cL =  127;  cR =    5; r16 =  cL %  cR; ASSERT(r16 ==  2);
 113    r16 = -1;
 114    cL =  127;  cR =   -5; r16 =  cL %  cR; ASSERT(r16 ==  2);
 115    r16 = -1;
 116    cL =  127; ucR =    5; r16 =  cL % ucR; ASSERT(r16 ==  2);
 117
 118    cL = -128;  cR =    5; r16 =  cL %  cR; ASSERT(r16 == -3);
 119    r16 = 0;
 120    cL = -128;  cR =   -5; r16 =  cL %  cR; ASSERT(r16 == -3);
 121    r16 = 0;
 122    cL = -128; ucR =    5; r16 =  cL % ucR; ASSERT(r16 == -3);
 123 }
 124
 125 void
 126 testOr(void)
 127 {
 128   {attrL}           char  cL;
 129   {attrL}  unsigned char ucL;
 130   {attrR}           char  cR;
 131   {attrR}  unsigned char ucR;
 132   volatile         short r16, r16b;
 133
 134    cL = 0x00;  cR = 0x80; r16 =  cL |  cR; r16b =  cR |  cL; ASSERT(r16 == (short) 0xff80); ASSERT(r16b == (short) 0xff80);
 135   ucL = 0x80;  cR = 0x00; r16 = ucL |  cR; r16b =  cR | ucL; ASSERT(r16 ==           0x80); ASSERT(r16b ==           0x80);
 136   ucL = 0x80; ucR = 0x80; r16 = ucL | ucR; r16b = ucR | ucL; ASSERT(r16 ==           0x80); ASSERT(r16b ==           0x80);
 137 }
 138
 139 void
 140 testXor(void)
 141 {
 142   {attrL}           char  cL;
 143   {attrL}  unsigned char ucL;
 144   {attrR}           char  cR;
 145   {attrR}  unsigned char ucR;
 146   volatile         short r16, r16b;
 147
 148    cL = 0x80;  cR = 0x80; r16 =  cL ^  cR; r16b =  cR ^  cL; ASSERT(r16 ==              0); ASSERT(r16b ==              0);
 149    cL = 0x80;  cR = 0x00; r16 =  cL ^  cR; r16b =  cR ^  cL; ASSERT(r16 == (short) 0xff80); ASSERT(r16b == (short) 0xff80);
 150
 151   ucL = 0x80;  cR = 0x80; r16 = ucL ^  cR; r16b =  cR ^ ucL; ASSERT(r16 == (short) 0xff00); ASSERT(r16b == (short) 0xff00);
 152   ucL = 0x80;  cR =    0; r16 = ucL ^  cR; r16b =  cR ^ ucL; ASSERT(r16 ==           0x80); ASSERT(r16b ==           0x80);
 153   ucL =    0;  cR = 0x80; r16 = ucL ^  cR; r16b =  cR ^ ucL; ASSERT(r16 == (short) 0xff80); ASSERT(r16b == (short) 0xff80);
 154
 155   ucL = 0x80; ucR = 0x80; r16 = ucL ^ ucR; r16b = ucR ^ ucL; ASSERT(r16 ==      0); ASSERT(r16b ==      0);
 156   ucL =    0; ucR = 0x80; r16 = ucL ^ ucR; r16b = ucR ^ ucL; ASSERT(r16 ==   0x80); ASSERT(r16b ==   0x80);
 157 }
 158
 159 void
 160 testAnd(void)
 161 {
 162   {attrL}           char  cL;
 163   {attrL}  unsigned char ucL;
 164   {attrR}           char  cR;
 165   {attrR}  unsigned char ucR;
 166   volatile         short r16, r16b;
 167
 168    cL = 0x80;  cR = 0x80; r16 =  cL &  cR; r16b =  cR &  cL; ASSERT(r16 == (short) 0xff80); ASSERT(r16b == (short) 0xff80);
 169   ucL = 0x80;  cR = 0x80; r16 = ucL &  cR; r16b =  cR & ucL; ASSERT(r16 ==           0x80); ASSERT(r16b ==           0x80);
 170   ucL = 0x80; ucR = 0x80; r16 = ucL & ucR; r16b = ucR & ucL; ASSERT(r16 ==           0x80); ASSERT(r16b ==           0x80);
 171 }