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

   1 /* Test operandOperation() in SDCCicode.c
   2
   3     type: char, short, LONG
   4  */
   5 #include <testfwk.h>
   6
   7 /* 64 bit hosts */
   8 #if defined(__alpha) || defined(__amd64)
   9 #  define LONG int
  10 #else
  11 #  define LONG long
  12 #endif
  13
  14 typedef   signed {type} stype;
  15 typedef unsigned {type} utype;
  16
  17 #if defined(PORT_HOST) || defined(SDCC_z80) || defined(SDCC_gbz80)
  18 #  define idata
  19 #  define code
  20 #endif
  21
  22 volatile char is8 = 8;
  23
  24   signed char  sc;
  25   signed short ss;
  26   signed LONG  sl;
  27 unsigned char  uc;
  28 unsigned short us;
  29 unsigned LONG  ul;
  30 volatile signed char  vsc;
  31 volatile signed short vss;
  32 volatile signed LONG  vsl;
  33 volatile unsigned char  vuc;
  34 volatile unsigned short vus;
  35 volatile unsigned LONG  vul;
  36 stype s;
  37 volatile stype vs;
  38 utype u;
  39 volatile utype vu;
  40
  41 unsigned LONG t1, t2;
  42
  43 int
  44 mulWrapper(int a, int b)
  45 {
  46     return a * b;
  47 }
  48
  49 void
  50 testOpOp(void)
  51 {
  52   /* mul signedness: usualBinaryConversions() */
  53   vsc = 0x7f;
  54   vuc = 0xfe;
  55
  56   sc = vsc * vsc;
  57   ASSERT(sc == 1);
  58   sc = vuc * vsc;
  59   ASSERT(sc == 2);
  60   sc = vuc * vuc;
  61   ASSERT(sc == 4);
  62
  63   ss = vsc * vsc;
  64   ASSERT(ss == 0x3f01);
  65   ss = vuc * vsc;
  66   ASSERT(ss == 0x7e02);
  67   ss = vuc * vuc;
  68   ASSERT(ss == (short) 0xfc04);
  69   /* after promotion the result of the multiplication is 'signed int', which overflows! */
  70   if (sizeof (int) == 2)
  71     ASSERT(vuc * vuc < 1);
  72   else
  73     {
  74       vus = 0xfffe;
  75       ASSERT(vus * vus < 1);
  76     }
  77
  78   /* mul ast: valMult() */
  79   ASSERT((stype) -3 * (stype) -1 == (stype)  3);
  80   ASSERT((stype) -3 * (stype)  1 == (stype) -3);
  81   ASSERT((stype)  3 * (stype) -1 == (stype) -3);
  82
  83   ASSERT((stype)  1 * (utype) 0xfffffff7 == (utype) 0xfffffff7);
  84
  85   ASSERT((unsigned char ) 0xfffffff8 * (unsigned char ) 0xfffffff7 == 0xef48);
  86   ASSERT(mulWrapper((unsigned short) 0xfffffff8, (unsigned short) 0xfffffff7) == (sizeof(int) == 2 ? 0x0048 : (unsigned int)0xffef0048));
  87   ASSERT((unsigned LONG ) 0xfffffff8 * (unsigned LONG ) 0xfffffff7 == 0x0048);
  88
  89   ASSERT((stype         ) 0xfffffff8 * (stype         ) 0xfffffff7 == 72);
  90
  91   ASSERT((signed char ) -1 * (unsigned char ) 0xfffffff7 == (sizeof(int) == 2 ? 0xff09 : 0xffffff09));
  92   ASSERT((signed short) -1 * (unsigned short) 0xfffffff7 == (sizeof(int) == 2 ?     9u : 0xffff0009));
  93   ASSERT((signed LONG ) -1 * (unsigned LONG ) 0xfffffff7 == 9u);
  94
  95   ASSERT((signed char ) -2 * (unsigned char ) 0x8004 == (sizeof(int) == 2 ? 0xfff8 : 0xfffffff8));
  96   ASSERT((signed short) -2 * (unsigned short) 0x8004 == (sizeof(int) == 2 ? 0xfff8 : 0xfffefff8));
  97   ASSERT((signed LONG ) -2 * (unsigned LONG ) 0x8004 == 0xfffefff8);
  98
  99   ASSERT(-1 * 0xfff7 == (sizeof(int) == 2 ? 9 : 0xffff0009)); // 0xfff7 is stored in 'unsigned int'
 100   // but:
 101   ASSERT(-1 * 65527  == -65527); // 65527 (== 0xfff7) is stored in 'signed LONG'
 102   ASSERT(-1 * 33000  == -33000);
 103
 104   ASSERT(1 *  10000  * is8 == (sizeof(int) == 2 ? 14464  :  80000)); /* int      */
 105   ASSERT(1 *  10000l * is8 == 80000);                                /* LONG     */
 106   ASSERT(1 *  40000u * is8 == (sizeof(int) == 2 ? 57856u : 320000)); /* unsigned */
 107   ASSERT(1 *  40000  * is8 == 320000);                               /* LONG     */
 108   ASSERT(1 * 0x4000  * is8 == (sizeof(int) == 2 ? 0 : 0x20000));     /* unsigned */
 109
 110   ASSERT(-2 * 1  < 1); /* comparison with 0 is optimized, so let's use 1 instead */
 111   ASSERT(-2 * 1u > 1);
 112   ASSERT(0x7fffu     * 2  > 1);
 113   ASSERT(0x7fffffffu * 2  > 1);
 114   if (sizeof (int) == 2)
 115     ASSERT(0x7fff * (unsigned char) 2 < 1);
 116   else
 117     ASSERT(mulWrapper(0x7fffffff, (unsigned char) 2) < 1);
 118   ASSERT(mulWrapper(0x7fffffff, (unsigned short) 2) < 1);
 119
 120   /* mul icode: operandOperation() */
 121   s = -3;
 122   ASSERT(s * (stype) -1 == (stype)  3);
 123   ASSERT(s * (stype)  1 == (stype) -3);
 124   s =  3;
 125   ASSERT(s * (stype) -1 == (stype) -3);
 126
 127   s = 1;
 128   ASSERT(s * (utype) 0xfffffff7 == (utype) 0xfffffff7);
 129   uc = (unsigned char ) 0xfffffff8;
 130   ASSERT(uc * (unsigned char ) 0xfffffff7 == 0xef48);
 131   us = (unsigned short) 0xfffffff8;
 132   ASSERT(us * (unsigned short) 0xfffffff7 == (sizeof(int) == 2 ? 0x0048 : 0xffef0048));
 133   ul = (unsigned LONG ) 0xfffffff8;
 134   ASSERT(ul * (unsigned LONG ) 0xfffffff7 == 0x0048);
 135   ul = (unsigned LONG ) 0xfffffff8;
 136
 137   ASSERT((stype         ) 0xfffffff8 * (stype         ) 0xfffffff7 == 72);
 138
 139   ASSERT((signed char ) -1 * (unsigned char ) 0xfffffff7 == (sizeof(int) == 2 ? 0xff09 : 0xffffff09));
 140   ASSERT((signed short) -1 * (unsigned short) 0xfffffff7 == (sizeof(int) == 2 ?     9u : 0xffff0009));
 141   ASSERT((signed LONG ) -1 * (unsigned LONG ) 0xfffffff7 == 9u);
 142
 143   ASSERT((signed char ) -2 * (unsigned char ) 0x8004 == (sizeof(int) == 2 ? 0xfff8 : 0xfffffff8));
 144   ASSERT((signed short) -2 * (unsigned short) 0x8004 == (sizeof(int) == 2 ? 0xfff8 : 0xfffefff8));
 145   ASSERT((signed LONG ) -2 * (unsigned LONG ) 0x8004 == 0xfffefff8);
 146
 147   /* div ast: valDiv() */
 148   ASSERT((stype) -12 / (stype) -3 == (stype)  4);
 149   ASSERT((stype) -12 / (stype)  3 == (stype) -4);
 150   ASSERT((stype)  12 / (stype) -3 == (stype) -4);
 151
 152   ASSERT((unsigned char ) -12 / (signed char ) -3 == (sizeof(int) == 2 ? 0xffaf : 0xffffffaf));
 153   ASSERT((unsigned short) -12 / (signed short) -3 == (sizeof(int) == 2 ?      0 : 0xffffaaaf));
 154   ASSERT((unsigned LONG ) -12 / (signed LONG ) -3 == 0);
 155   ASSERT((utype)          -12 / (stype)         3 == (stype) 0x55555551);
 156   ASSERT((unsigned char )  12 / (signed char ) -3 == -4);
 157   ASSERT((unsigned short)  12 / (signed short) -3 == (sizeof(int) == 2 ?      0 : 0xfffffffc));
 158   ASSERT((unsigned LONG )  12 / (signed LONG ) -3 == 0);
 159
 160   ASSERT((stype)        -12 / (utype)          -3 == 0);
 161   ASSERT((signed char ) -12 / (unsigned char )  3 == -4);
 162   ASSERT((signed short) -12 / (unsigned short)  3 == (sizeof(int) == 2 ? 0x5551 :  -4));
 163   ASSERT((signed LONG ) -12 / (unsigned LONG )  3 == 0x55555551);
 164   ASSERT((stype)         12 / (utype)          -3 == 0);
 165
 166   ASSERT(12u / 3 * 10000 == 40000);
 167
 168   ASSERT(-1 / 1 < 0);
 169
 170   /* div icode: operandOperation() */
 171   s = -12;
 172   ASSERT(s / (stype) -3 == (stype)  4);
 173   s = -12;
 174   ASSERT(s / (stype)  3 == (stype) -4);
 175   s = 12;
 176   ASSERT(s / (stype) -3 == (stype) -4);
 177
 178   uc = -12;
 179   ASSERT(uc / (signed char ) -3 == (sizeof(int) == 2 ? 0xffaf : 0xffffffaf));
 180   us = -12;
 181   ASSERT(us / (signed short) -3 == (sizeof(int) == 2 ?      0 : 0xffffaaaf));
 182   ul = -12;
 183   ASSERT(ul / (signed LONG ) -3 == 0);
 184   u  = -12;
 185   ASSERT(u  / (stype)         3 == (stype) 0x55555551);
 186   uc = 12;
 187   ASSERT(uc / (signed char ) -3 == -4);
 188   us = 12;
 189   ASSERT(us / (signed short) -3 == (sizeof(int) == 2 ?      0 : 0xfffffffc));
 190   ul = 12;
 191   ASSERT(ul / (signed LONG ) -3 == 0);
 192
 193   s  = -12;
 194   ASSERT(s  / (utype)          -3 == 0);
 195   sc = -12;
 196   ASSERT(sc / (unsigned char )  3 == -4);
 197   ss = -12;
 198   ASSERT(ss / (unsigned short)  3 == (sizeof(int) == 2 ? 0x5551 :  -4));
 199   sl = -12;
 200   ASSERT(sl / (unsigned LONG )  3 == 0x55555551);
 201   s  = 12;
 202   ASSERT(s  / (utype)          -3 == 0);
 203
 204
 205   /* mod ast: valMod() */
 206   /* -11 : 0xfff5 */
 207   /* -17 : 0xffef */
 208   ASSERT((stype) -17 % (stype) -11 == (stype) -6);
 209   ASSERT((stype) -17 % (stype)  11 == (stype) -6);
 210   ASSERT((stype)  17 % (stype) -11 == (stype)  6);
 211   ASSERT((unsigned char ) -17 % (signed char ) -11 ==   8);
 212   ASSERT((unsigned short) -17 % (signed short) -11 == (sizeof(int) == 2 ? -17 : 3));
 213   ASSERT((unsigned LONG ) -17 % (signed LONG ) -11 == -17);
 214   ASSERT((unsigned char ) -17 % (signed char )  11 ==   8);
 215   ASSERT((unsigned short) -17 % (signed short)  11 ==   3);
 216   ASSERT((unsigned LONG ) -17 % (signed LONG )  11 ==   9);
 217   ASSERT((unsigned char )  17 % (signed char ) -11 ==   6);
 218   ASSERT((unsigned short)  17 % (signed short) -11 == (sizeof(int) == 2 ? 17 : 6));
 219   ASSERT((unsigned LONG )  17 % (signed LONG ) -11 ==  17);
 220
 221   ASSERT(-3 % 2 < 0);
 222
 223
 224   /* add */
 225   ASSERT( 80  +  80  == 160);
 226   ASSERT(150  + 150  == 300);
 227   ASSERT(160u + 160u == 320);
 228 }