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