1 #include <stdint.h> 2 3 volatile int8_t c; 4 5 /* sorry about the uggly source, 6 but this way it can be the same as in the regression tests */ 7 #define ASSERT(x) c = (x) 8 9 int8_t s8; 10 uint8_t u8; 11 12 int16_t s16; 13 uint16_t u16; 14 15 int32_t s32; 16 uint32_t u32; 17 18 #ifdef TEST1 foo(void)19void foo(void) 20 { 21 ASSERT (! (INT8_MIN - 1 == s8)); /* WARNING */ 22 ASSERT (! (INT8_MAX + 1 == s8)); /* WARNING */ 23 ASSERT ( (INT8_MIN - 1 != s8)); /* WARNING */ 24 ASSERT ( (INT8_MAX + 1 != s8)); /* WARNING */ 25 ASSERT ( (INT8_MIN - 1 < s8)); /* WARNING */ 26 ASSERT (! (INT8_MAX < s8)); /* WARNING */ 27 ASSERT ( (INT8_MIN <= s8)); /* WARNING */ 28 ASSERT (! (INT8_MAX + 1 <= s8)); /* WARNING */ 29 ASSERT (! (INT8_MIN > s8)); /* WARNING */ 30 ASSERT ( (INT8_MAX + 1 > s8)); /* WARNING */ 31 ASSERT (! (INT8_MIN - 1 >= s8)); /* WARNING */ 32 ASSERT ( (INT8_MAX >= s8)); /* WARNING */ 33 34 ASSERT (! ( 0 - 1 == u8)); /* WARNING */ 35 ASSERT (! (UINT8_MAX + 1 == u8)); /* WARNING */ 36 ASSERT ( ( 0 - 1 != u8)); /* WARNING */ 37 ASSERT ( (UINT8_MAX + 1 != u8)); /* WARNING */ 38 ASSERT ( ( 0 - 1 < u8)); /* WARNING */ 39 ASSERT (! (UINT8_MAX < u8)); /* WARNING */ 40 ASSERT ( ( 0 <= u8)); /* WARNING */ 41 ASSERT (! (UINT8_MAX + 1 <= u8)); /* WARNING */ 42 ASSERT (! ( 0 > u8)); /* WARNING */ 43 ASSERT ( (UINT8_MAX + 1 > u8)); /* WARNING */ 44 ASSERT (! ( 0 - 1 >= u8)); /* WARNING */ 45 ASSERT ( (UINT8_MAX >= u8)); /* WARNING */ 46 47 /* force extension to long to avoid int (16 bit) overflow */ 48 ASSERT (! (INT16_MIN - 1L == s16)); /* WARNING */ 49 ASSERT (! (INT16_MAX + 1L == s16)); /* WARNING */ 50 ASSERT ( (INT16_MIN - 1L != s16)); /* WARNING */ 51 ASSERT ( (INT16_MAX + 1L != s16)); /* WARNING */ 52 ASSERT ( (INT16_MIN - 1L < s16)); /* WARNING */ 53 ASSERT (! (INT16_MAX < s16)); /* WARNING */ 54 ASSERT ( (INT16_MIN <= s16)); /* WARNING */ 55 ASSERT (! (INT16_MAX + 1L <= s16)); /* WARNING */ 56 ASSERT (! (INT16_MIN > s16)); /* WARNING */ 57 ASSERT ( (INT16_MAX + 1L > s16)); /* WARNING */ 58 ASSERT (! (INT16_MIN - 1L >= s16)); /* WARNING */ 59 ASSERT ( (INT16_MAX >= s16)); /* WARNING */ 60 61 ASSERT (! ( 0 - 1L == u16)); /* WARNING */ 62 ASSERT (! (UINT16_MAX + 1L == u16)); /* WARNING */ 63 ASSERT ( ( 0 - 1L != u16)); /* WARNING */ 64 ASSERT ( (UINT16_MAX + 1L != u16)); /* WARNING */ 65 ASSERT ( ( 0 - 1L < u16)); /* WARNING */ 66 ASSERT (! (UINT16_MAX < u16)); /* WARNING */ 67 ASSERT ( ( 0 <= u16)); /* WARNING */ 68 ASSERT (! (UINT16_MAX + 1L <= u16)); /* WARNING */ 69 ASSERT (! ( 0 > u16)); /* WARNING */ 70 ASSERT ( (UINT16_MAX + 1L > u16)); /* WARNING */ 71 ASSERT (! ( 0 - 1L >= u16)); /* WARNING */ 72 ASSERT ( (UINT16_MAX >= u16)); /* WARNING */ 73 74 /* sdcc can't hold a number (INT32_MIN - 1) or (INT32_MAX + 1), 75 there's no 'double' or 'long long' */ 76 /* ASSERT (! (INT32_MIN - 1 == s32)); */ 77 /* ASSERT (! (INT32_MAX + 1 == s32)); */ 78 /* ASSERT ( (INT32_MIN - 1 != s32)); */ 79 /* ASSERT ( (INT32_MAX + 1 != s32)); */ 80 /* ASSERT ( (INT32_MIN - 1 < s32)); */ 81 ASSERT (! (INT32_MAX < s32)); /* WARNING(SDCC) */ 82 ASSERT ( (INT32_MIN <= s32)); /* WARNING(SDCC) */ 83 /* ASSERT (! (INT32_MAX + 1 <= s32)); */ 84 ASSERT (! (INT32_MIN > s32)); /* WARNING(SDCC) */ 85 /* ASSERT ( (INT32_MAX + 1 > s32)); */ 86 /* ASSERT (! (INT32_MIN - 1 >= s32)); */ 87 ASSERT ( (INT32_MAX >= s32)); /* WARNING(SDCC) */ 88 89 /* (0 - 1) wraps around to UINT32_MAX -> untestable */ 90 /* ASSERT (! ( 0 - 1 == u32)); */ 91 /* ASSERT (! (UINT32_MAX + 1 == u32)); */ 92 /* ASSERT ( ( 0 - 1 != u32)); */ 93 /* ASSERT ( (UINT32_MAX + 1 != u32)); */ 94 /* ASSERT ( ( 0 - 1 < u32)); */ 95 ASSERT (! (UINT32_MAX < u32)); /* WARNING(SDCC) */ 96 ASSERT ( ( 0 <= u32)); /* WARNING(SDCC) */ 97 /* ASSERT (! (UINT32_MAX + 1 <= u32)); */ 98 ASSERT (! ( 0 > u32)); /* WARNING(SDCC) */ 99 /* ASSERT ( (UINT32_MAX + 1 > u32)); */ 100 /* ASSERT (! ( 0 - 1 >= u32)); */ 101 ASSERT ( (UINT32_MAX >= u32)); /* WARNING(SDCC) */ 102 } 103 #endif 104 105 #ifdef TEST2 foo(void)106void foo(void) 107 { 108 s8 = -129; /* WARNING */ 109 s8 = INT8_MIN; 110 s8 = UINT8_MAX; /* WARNING */ 111 s8 = 256; /* WARNING */ 112 113 s8 = -129; /* WARNING */ 114 u8 = INT8_MIN; /* WARNING */ 115 u8 = UINT8_MAX; 116 u8 = 256; /* WARNING */ 117 118 s16 = -32769L; /* WARNING */ 119 s16 = INT16_MIN; 120 s16 = UINT16_MAX; /* WARNING */ 121 s16 = 65536L; /* WARNING */ 122 123 s16 = -32769L; /* WARNING */ 124 u16 = INT16_MIN; /* WARNING */ 125 u16 = UINT16_MAX; 126 u16 = 65536L; /* WARNING */ 127 128 /* sdcc can't hold a number (INT32_MIN - 1) or (INT32_MAX + 1), 129 there's no 'double' or 'long long' */ 130 s32 = INT32_MIN; 131 s32 = UINT32_MAX; /* WARNING */ 132 133 u32 = INT32_MIN; /* WARNING */ 134 u32 = UINT32_MAX; 135 } 136 #endif 137 138 /* This test has been disabled. I don't think that signed/unsigned bool */ 139 /* is a valid type. -- EEP */ 140 #ifdef TEST3_DISABLED 141 #include <stdbool.h> 142 foo(void)143void foo(void) 144 { 145 #if defined(PORT_HOST) 146 volatile bool sb, ub; 147 #else 148 volatile signed bool sb; 149 volatile unsigned bool ub; 150 #endif 151 152 sb = -2; 153 sb = -1; 154 sb = 0; 155 sb = 1; 156 157 ub = -1; 158 ub = 0; 159 ub = 1; 160 ub = 2; 161 162 ASSERT (! (-2 == sb)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ 163 ASSERT ( (-1 == sb)); 164 ASSERT ( ( 0 == sb)); 165 ASSERT (! ( 1 == sb)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ 166 167 ASSERT ( (-2 != sb)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ 168 ASSERT ( (-1 != sb)); 169 ASSERT ( ( 0 != sb)); 170 ASSERT ( ( 1 != sb)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ 171 172 ASSERT ( (-2 < sb)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ 173 ASSERT ( (-1 < sb)); 174 ASSERT (! ( 0 < sb)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ 175 176 ASSERT ( (-1 <= sb)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ 177 ASSERT ( ( 0 <= sb)); 178 ASSERT (! ( 1 <= sb)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ 179 180 ASSERT (! (-1 > sb)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ 181 ASSERT ( ( 0 > sb)); 182 ASSERT ( ( 1 > sb)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ 183 184 ASSERT (! (-2 >= sb)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ 185 ASSERT ( (-1 >= sb)); 186 ASSERT ( ( 0 >= sb)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ 187 188 189 ASSERT (! (-1 == ub)); /* WARNING(SDCC) */ 190 ASSERT ( ( 0 == ub)); 191 ASSERT ( ( 1 == ub)); 192 ASSERT (! ( 2 == ub)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ 193 194 ASSERT ( (-1 != ub)); /* WARNING(SDCC) */ 195 ASSERT ( ( 0 != ub)); 196 ASSERT ( ( 1 != ub)); 197 ASSERT ( ( 2 != ub)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ 198 199 ASSERT ( (-1 < ub)); /* WARNING(SDCC) */ 200 ASSERT ( ( 0 < ub)); 201 ASSERT (! ( 1 < ub)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ 202 203 ASSERT ( ( 0 <= ub)); /* WARNING(SDCC) */ 204 ASSERT ( ( 1 <= ub)); 205 ASSERT (! ( 2 <= ub)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ 206 207 ASSERT (! ( 0 > ub)); /* WARNING(SDCC) */ 208 ASSERT ( ( 1 > ub)); 209 ASSERT ( ( 2 > ub)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ 210 211 ASSERT (! (-1 >= ub)); /* WARNING(SDCC) */ 212 ASSERT ( ( 0 >= ub)); 213 ASSERT ( ( 1 >= ub)); /* WARNING(SDCC_mcs51|SDCC_ds390) */ 214 } 215 #endif 216 217 #ifdef TEST4 foo(void)218void foo(void) 219 { 220 volatile struct { 221 signed sb1:1; 222 signed sb3:3; 223 unsigned ub1:1; 224 unsigned ub3:3; 225 } str; 226 227 str.sb1 = -2; /* WARNING */ 228 str.sb1 = -1; 229 str.sb1 = 1; /* WARNING */ 230 str.sb1 = 2; /* WARNING */ 231 232 str.ub1 = -2; /* WARNING */ 233 str.ub1 = -1; /* WARNING */ 234 str.ub1 = 1; 235 str.ub1 = 2; /* WARNING */ 236 237 str.sb3 = -5; /* WARNING */ 238 str.sb3 = -4; 239 str.sb3 = 7; /* WARNING */ 240 str.sb3 = 8; /* WARNING */ 241 242 str.ub3 = -5; /* WARNING */ 243 str.ub3 = -4; /* WARNING */ 244 str.ub3 = 7; 245 str.ub3 = 8; /* WARNING */ 246 247 ASSERT (! (-2 == str.sb1)); /* WARNING */ 248 ASSERT ( (-1 == str.sb1)); 249 ASSERT ( ( 0 == str.sb1)); 250 ASSERT (! ( 1 == str.sb1)); /* WARNING */ 251 252 ASSERT (! (-1 == str.ub1)); /* WARNING(SDCC) */ 253 ASSERT ( ( 0 == str.ub1)); 254 ASSERT ( ( 1 == str.ub1)); 255 ASSERT (! ( 2 == str.ub1)); /* WARNING(SDCC) */ 256 257 ASSERT (! (-5 == str.sb3)); /* WARNING */ 258 ASSERT ( (-4 == str.sb3)); 259 ASSERT ( ( 3 == str.sb3)); 260 ASSERT (! ( 4 == str.sb3)); /* WARNING */ 261 262 ASSERT (! (-1 == str.ub3)); /* WARNING(SDCC) */ 263 ASSERT ( ( 0 == str.ub3)); 264 ASSERT ( ( 7 == str.ub3)); 265 ASSERT (! ( 8 == str.ub3)); /* WARNING(SDCC) */ 266 } 267 #endif 268