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