* support/regression/tests/constantRange.c: added

* support/valdiag/tests/constantRange.c: added

git-svn-id: https://sdcc.svn.sourceforge.net/svnroot/sdcc/trunk/sdcc@4207 4a8a32a2-be11-0410-ad9d-d568d2c75423

diff --git a/support/regression/tests/constantRange.c b/support/regression/tests/constantRange.c
new file mode 100644 (file)
index 0000000..15c3ea0
--- /dev/null
+++ b/support/regression/tests/constantRange.c
@@ -0,0 +1,193 @@
+/** constant range tests.
+
+*/
+
+#include <testfwk.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+ int8_t s8;
+uint8_t u8;
+
+ int16_t s16;
+uint16_t u16;
+
+ int32_t s32;
+uint32_t u32;
+
+void
+testConstantRange (void)
+{
+  ASSERT (! (INT8_MIN - 1 == s8));
+  ASSERT (! (INT8_MAX + 1 == s8));
+  ASSERT (  (INT8_MIN - 1 != s8));
+  ASSERT (  (INT8_MAX + 1 != s8));
+  ASSERT (  (INT8_MIN - 1 <  s8));
+  ASSERT (! (INT8_MAX     <  s8));
+  ASSERT (  (INT8_MIN     <= s8));
+  ASSERT (! (INT8_MAX     <= s8));
+  ASSERT (! (INT8_MIN     >  s8));
+  ASSERT (  (INT8_MAX + 1 >  s8));
+  ASSERT (! (INT8_MIN - 1 >= s8));
+  ASSERT (  (INT8_MAX     >= s8));
+
+  ASSERT (! (        0 - 1 == u8));
+  ASSERT (! (UINT8_MAX + 1 == u8));
+  ASSERT (  (        0 - 1 != u8));
+  ASSERT (  (UINT8_MAX + 1 != u8));
+  ASSERT (  (        0 - 1 <  u8));
+  ASSERT (! (UINT8_MAX     <  u8));
+  ASSERT (  (        0     <= u8));
+  ASSERT (! (UINT8_MAX + 1 <= u8));
+  ASSERT (! (        0     >  u8));
+  ASSERT (  (UINT8_MAX + 1 >  u8));
+  ASSERT (! (        0 - 1 >= u8));
+  ASSERT (  (UINT8_MAX     >= u8));
+
+  /* force extension to long to avoid int (16 bit) overflow */
+  ASSERT (! (INT16_MIN - 1L == s16));
+  ASSERT (! (INT16_MAX + 1L == s16));
+  ASSERT (  (INT16_MIN - 1L != s16));
+  ASSERT (  (INT16_MAX + 1L != s16));
+  ASSERT (  (INT16_MIN - 1L <  s16));
+  ASSERT (! (INT16_MAX      <  s16));
+  ASSERT (  (INT16_MIN      <= s16));
+  ASSERT (! (INT16_MAX      <= s16));
+  ASSERT (! (INT16_MIN      >  s16));
+  ASSERT (  (INT16_MAX + 1L >  s16));
+  ASSERT (! (INT16_MIN - 1L >= s16));
+  ASSERT (  (INT16_MAX      >= s16));
+
+  ASSERT (! (         0 - 1  == u16));
+  ASSERT (! (UINT16_MAX + 1L == u16));
+  ASSERT (  (         0 - 1  != u16));
+  ASSERT (  (UINT16_MAX + 1L != u16));
+  ASSERT (  (         0 - 1  <  u16));
+  ASSERT (! (UINT16_MAX      <  u16));
+  ASSERT (  (         0      <= u16));
+  ASSERT (! (UINT16_MAX + 1L <= u16));
+  ASSERT (! (         0      >  u16));
+  ASSERT (  (UINT16_MAX + 1L >  u16));
+  ASSERT (! (         0 - 1  >= u16));
+  ASSERT (  (UINT16_MAX      >= u16));
+
+   /* sdcc can't hold a number (INT32_MIN - 1) or (INT32_MAX + 1),
+      there's no 'double' or 'long long' */
+/* ASSERT (! (INT32_MIN - 1 == s32)); */
+/* ASSERT (! (INT32_MAX + 1 == s32)); */
+/* ASSERT (  (INT32_MIN - 1 != s32)); */
+/* ASSERT (  (INT32_MAX + 1 != s32)); */
+/* ASSERT (  (INT32_MIN - 1 <  s32)); */
+   ASSERT (! (INT32_MAX     <  s32));
+   ASSERT (  (INT32_MIN     <= s32));
+   ASSERT (! (INT32_MAX     <= s32));
+   ASSERT (! (INT32_MIN     >  s32));
+/* ASSERT (  (INT32_MAX + 1 >  s32)); */
+/* ASSERT (! (INT32_MIN - 1 >= s32)); */
+   ASSERT (  (INT32_MAX     >= s32));
+
+   ASSERT (! (         0 - 1 == u32));
+/* ASSERT (! (UINT32_MAX + 1 == u32)); */
+   ASSERT (  (         0 - 1 != u32));
+/* ASSERT (  (UINT32_MAX + 1 != u32)); */
+   ASSERT (  (         0 - 1 <  u32));
+   ASSERT (! (UINT32_MAX     <  u32));
+   ASSERT (  (         0     <= u32));
+/* ASSERT (! (UINT32_MAX + 1 <= u32)); */
+   ASSERT (! (         0     >  u32));
+/* ASSERT (  (UINT32_MAX + 1 >  u32)); */
+   ASSERT (! (         0 - 1 >= u32));
+   ASSERT (  (UINT32_MAX     >= u32));
+}
+
+void
+testFoo1(void)
+{
+#if defined(PORT_HOST)
+   volatile bool sb, ub;
+#else
+   volatile   signed bool sb;
+   volatile unsigned bool ub;
+#endif
+
+  sb = 0;
+  ub = 0;
+
+  ASSERT (! (-1 == sb));
+  ASSERT (  ( 0 == sb));
+  ASSERT (! ( 1 == sb));
+
+  ASSERT (  (-1 != sb));
+  ASSERT (! ( 0 != sb));
+  ASSERT (  ( 1 != sb));
+
+  ASSERT (  (-1 <  sb));
+  ASSERT (! ( 0 <  sb));
+
+  ASSERT (  ( 0 <= sb));
+  ASSERT (! ( 1 <= sb));
+
+  ASSERT (! ( 0 >  sb));
+  ASSERT (  ( 1 >  sb));
+
+  ASSERT (! (-1 >= sb));
+  ASSERT (  ( 0 >= sb));
+
+
+  ASSERT (! (-1 == ub));
+  ASSERT (  ( 0 == ub));
+  ASSERT (! ( 1 == ub));
+
+  ASSERT (  (-1 != ub));
+  ASSERT (! ( 0 != ub));
+  ASSERT (  ( 1 != ub));
+
+  ASSERT (  (-1 <  ub));
+  ASSERT (! ( 0 <  ub));
+
+  ASSERT (  ( 0 <= ub));
+  ASSERT (! ( 1 <= ub));
+
+  ASSERT (! ( 0 >  ub));
+  ASSERT (  ( 1 >  ub));
+
+  ASSERT (! (-1 >= ub));
+  ASSERT (  ( 0 >= ub));
+}
+
+void
+testFoo2(void)
+{
+  volatile struct {
+      signed sb1:1;
+      signed sb3:3;
+    unsigned ub1:1;
+    unsigned ub3:3;
+  } str;
+
+  str.sb1 = 0;
+  str.ub1 = 0;
+  str.sb3 = 0;
+  str.ub3 = 0;
+
+  ASSERT (! (-2 == str.sb1));
+  ASSERT (! (-1 == str.sb1));
+  ASSERT (  ( 0 == str.sb1));
+  ASSERT (! ( 1 == str.sb1));
+
+  ASSERT (! (-1 == str.ub1));
+  ASSERT (  ( 0 == str.ub1));
+  ASSERT (! ( 1 == str.ub1));
+  ASSERT (! ( 2 == str.ub1));
+
+  ASSERT (! (-5 == str.sb3));
+  ASSERT (! (-4 == str.sb3));
+  ASSERT (  ( 0 == str.sb3));
+  ASSERT (! ( 3 == str.sb3));
+  ASSERT (! ( 4 == str.sb3));
+
+  ASSERT (! (-1 == str.ub3));
+  ASSERT (  ( 0 == str.ub3));
+  ASSERT (! ( 7 == str.ub3));
+  ASSERT (! ( 8 == str.ub3));
+}

diff --git a/support/valdiag/tests/constantRange.c b/support/valdiag/tests/constantRange.c
new file mode 100644 (file)
index 0000000..9253aef
--- /dev/null
+++ b/support/valdiag/tests/constantRange.c
@@ -0,0 +1,265 @@
+#include <stdint.h>
+
+volatile int8_t c;
+
+/* sorry about the uggly source,
+   but this way it can be the same as in the regression tests */
+#define ASSERT(x) c = (x)
+
+ int8_t s8;
+uint8_t u8;
+
+ int16_t s16;
+uint16_t u16;
+
+ int32_t s32;
+uint32_t u32;
+
+#ifdef TEST1
+void foo(void)
+{
+  ASSERT (! (INT8_MIN - 1 == s8));             /* WARNING */
+  ASSERT (! (INT8_MAX + 1 == s8));             /* WARNING */
+  ASSERT (  (INT8_MIN - 1 != s8));             /* WARNING */
+  ASSERT (  (INT8_MAX + 1 != s8));             /* WARNING */
+  ASSERT (  (INT8_MIN - 1 <  s8));             /* WARNING */
+  ASSERT (! (INT8_MAX     <  s8));             /* WARNING */
+  ASSERT (  (INT8_MIN     <= s8));             /* WARNING */
+  ASSERT (! (INT8_MAX + 1 <= s8));             /* WARNING */
+  ASSERT (! (INT8_MIN     >  s8));             /* WARNING */
+  ASSERT (  (INT8_MAX + 1 >  s8));             /* WARNING */
+  ASSERT (! (INT8_MIN - 1 >= s8));             /* WARNING */
+  ASSERT (  (INT8_MAX     >= s8));             /* WARNING */
+
+  ASSERT (! (        0 - 1 == u8));            /* WARNING */
+  ASSERT (! (UINT8_MAX + 1 == u8));            /* WARNING */
+  ASSERT (  (        0 - 1 != u8));            /* WARNING */
+  ASSERT (  (UINT8_MAX + 1 != u8));            /* WARNING */
+  ASSERT (  (        0 - 1 <  u8));            /* WARNING */
+  ASSERT (! (UINT8_MAX     <  u8));            /* WARNING */
+  ASSERT (  (        0     <= u8));            /* WARNING */
+  ASSERT (! (UINT8_MAX + 1 <= u8));            /* WARNING */
+  ASSERT (! (        0     >  u8));            /* WARNING */
+  ASSERT (  (UINT8_MAX + 1 >  u8));            /* WARNING */
+  ASSERT (! (        0 - 1 >= u8));            /* WARNING */
+  ASSERT (  (UINT8_MAX     >= u8));            /* WARNING */
+
+  /* force extension to long to avoid int (16 bit) overflow */
+  ASSERT (! (INT16_MIN - 1L == s16));          /* WARNING */
+  ASSERT (! (INT16_MAX + 1L == s16));          /* WARNING */
+  ASSERT (  (INT16_MIN - 1L != s16));          /* WARNING */
+  ASSERT (  (INT16_MAX + 1L != s16));          /* WARNING */
+  ASSERT (  (INT16_MIN - 1L <  s16));          /* WARNING */
+  ASSERT (! (INT16_MAX      <  s16));          /* WARNING */
+  ASSERT (  (INT16_MIN      <= s16));          /* WARNING */
+  ASSERT (! (INT16_MAX + 1L <= s16));          /* WARNING */
+  ASSERT (! (INT16_MIN      >  s16));          /* WARNING */
+  ASSERT (  (INT16_MAX + 1L >  s16));          /* WARNING */
+  ASSERT (! (INT16_MIN - 1L >= s16));          /* WARNING */
+  ASSERT (  (INT16_MAX      >= s16));          /* WARNING */
+
+  ASSERT (! (         0 - 1L == u16));         /* WARNING */
+  ASSERT (! (UINT16_MAX + 1L == u16));         /* WARNING */
+  ASSERT (  (         0 - 1L != u16));         /* WARNING */
+  ASSERT (  (UINT16_MAX + 1L != u16));         /* WARNING */
+  ASSERT (  (         0 - 1L <  u16));         /* WARNING */
+  ASSERT (! (UINT16_MAX      <  u16));         /* WARNING */
+  ASSERT (  (         0      <= u16));         /* WARNING */
+  ASSERT (! (UINT16_MAX + 1L <= u16));         /* WARNING */
+  ASSERT (! (         0      >  u16));         /* WARNING */
+  ASSERT (  (UINT16_MAX + 1L >  u16));         /* WARNING */
+  ASSERT (! (         0 - 1L >= u16));         /* WARNING */
+  ASSERT (  (UINT16_MAX      >= u16));         /* WARNING */
+
+   /* sdcc can't hold a number (INT32_MIN - 1) or (INT32_MAX + 1),
+      there's no 'double' or 'long long' */
+/* ASSERT (! (INT32_MIN - 1 == s32)); */
+/* ASSERT (! (INT32_MAX + 1 == s32)); */
+/* ASSERT (  (INT32_MIN - 1 != s32)); */
+/* ASSERT (  (INT32_MAX + 1 != s32)); */
+/* ASSERT (  (INT32_MIN - 1 <  s32)); */
+   ASSERT (! (INT32_MAX     <  s32));          /* WARNING(SDCC) */
+   ASSERT (  (INT32_MIN     <= s32));          /* WARNING(SDCC) */
+/* ASSERT (! (INT32_MAX + 1 <= s32)); */
+   ASSERT (! (INT32_MIN     >  s32));          /* WARNING(SDCC) */
+/* ASSERT (  (INT32_MAX + 1 >  s32)); */
+/* ASSERT (! (INT32_MIN - 1 >= s32)); */
+   ASSERT (  (INT32_MAX     >= s32));          /* WARNING(SDCC) */
+
+   /* (0 - 1) wraps around to UINT32_MAX -> untestable */
+/* ASSERT (! (         0 - 1 == u32)); */
+/* ASSERT (! (UINT32_MAX + 1 == u32)); */
+/* ASSERT (  (         0 - 1 != u32)); */
+/* ASSERT (  (UINT32_MAX + 1 != u32)); */
+/* ASSERT (  (         0 - 1 <  u32)); */
+   ASSERT (! (UINT32_MAX     <  u32));         /* WARNING(SDCC) */
+   ASSERT (  (         0     <= u32));         /* WARNING(SDCC) */
+/* ASSERT (! (UINT32_MAX + 1 <= u32)); */
+   ASSERT (! (         0     >  u32));         /* WARNING(SDCC) */
+/* ASSERT (  (UINT32_MAX + 1 >  u32)); */
+/* ASSERT (! (         0 - 1 >= u32)); */
+   ASSERT (  (UINT32_MAX     >= u32));         /* WARNING(SDCC) */
+}
+#endif
+
+#ifdef TEST2
+void foo(void)
+{
+   s8 = -129;          /* WARNING */
+   s8 =  INT8_MIN;
+   s8 = UINT8_MAX;
+   s8 =  256;          /* WARNING */
+
+   s8 = -129;          /* WARNING */
+   u8 =  INT8_MIN;
+   u8 = UINT8_MAX;
+   u8 =  256;          /* WARNING */
+
+   s16 = -32769L;      /* WARNING */
+   s16 =  INT16_MIN;
+   s16 = UINT16_MAX;
+   s16 =  65536L;      /* WARNING */
+
+   s16 = -32769L;      /* WARNING */
+   u16 =  INT16_MIN;
+   u16 = UINT16_MAX;
+   u16 =  65536L;      /* WARNING */
+
+   /* sdcc can't hold a number (INT32_MIN - 1) or (INT32_MAX + 1),
+      there's no 'double' or 'long long' */
+   s32 =  INT32_MIN;
+   s32 = UINT32_MAX;
+
+   u32 =  INT32_MIN;
+   u32 = UINT32_MAX;
+}
+#endif
+
+#ifdef TEST3
+#include <stdbool.h>
+
+void foo(void)
+{
+#if defined(PORT_HOST)
+   volatile bool sb, ub;
+#else
+   volatile   signed bool sb;
+   volatile unsigned bool ub;
+#endif
+
+  sb = -2;
+  sb = -1;
+  sb =  0;
+  sb =  1;
+
+  ub = -1;
+  ub =  0;
+  ub =  1;
+  ub =  2;
+
+  ASSERT (! (-2 == sb));       /* WARNING(SDCC_mcs51|SDCC_ds390) */
+  ASSERT (  (-1 == sb));
+  ASSERT (  ( 0 == sb));
+  ASSERT (! ( 1 == sb));       /* WARNING(SDCC_mcs51|SDCC_ds390) */
+
+  ASSERT (  (-2 != sb));       /* WARNING(SDCC_mcs51|SDCC_ds390) */
+  ASSERT (  (-1 != sb));
+  ASSERT (  ( 0 != sb));
+  ASSERT (  ( 1 != sb));       /* WARNING(SDCC_mcs51|SDCC_ds390) */
+
+  ASSERT (  (-2 <  sb));       /* WARNING(SDCC_mcs51|SDCC_ds390) */
+  ASSERT (  (-1 <  sb));
+  ASSERT (! ( 0 <  sb));       /* WARNING(SDCC_mcs51|SDCC_ds390) */
+
+  ASSERT (  (-1 <= sb));       /* WARNING(SDCC_mcs51|SDCC_ds390) */
+  ASSERT (  ( 0 <= sb));
+  ASSERT (! ( 1 <= sb));       /* WARNING(SDCC_mcs51|SDCC_ds390) */
+
+  ASSERT (! (-1 >  sb));       /* WARNING(SDCC_mcs51|SDCC_ds390) */
+  ASSERT (  ( 0 >  sb));
+  ASSERT (  ( 1 >  sb));       /* WARNING(SDCC_mcs51|SDCC_ds390) */
+
+  ASSERT (! (-2 >= sb));       /* WARNING(SDCC_mcs51|SDCC_ds390) */
+  ASSERT (  (-1 >= sb));
+  ASSERT (  ( 0 >= sb));       /* WARNING(SDCC_mcs51|SDCC_ds390) */
+
+
+  ASSERT (! (-1 == ub));       /* WARNING(SDCC) */
+  ASSERT (  ( 0 == ub));
+  ASSERT (  ( 1 == ub));
+  ASSERT (! ( 2 == ub));       /* WARNING(SDCC_mcs51|SDCC_ds390) */
+
+  ASSERT (  (-1 != ub));       /* WARNING(SDCC) */
+  ASSERT (  ( 0 != ub));
+  ASSERT (  ( 1 != ub));
+  ASSERT (  ( 2 != ub));       /* WARNING(SDCC_mcs51|SDCC_ds390) */
+
+  ASSERT (  (-1 <  ub));       /* WARNING(SDCC) */
+  ASSERT (  ( 0 <  ub));
+  ASSERT (! ( 1 <  ub));       /* WARNING(SDCC_mcs51|SDCC_ds390) */
+
+  ASSERT (  ( 0 <= ub));       /* WARNING(SDCC) */
+  ASSERT (  ( 1 <= ub));
+  ASSERT (! ( 2 <= ub));       /* WARNING(SDCC_mcs51|SDCC_ds390) */
+
+  ASSERT (! ( 0 >  ub));       /* WARNING(SDCC) */
+  ASSERT (  ( 1 >  ub));
+  ASSERT (  ( 2 >  ub));       /* WARNING(SDCC_mcs51|SDCC_ds390) */
+
+  ASSERT (! (-1 >= ub));       /* WARNING(SDCC) */
+  ASSERT (  ( 0 >= ub));
+  ASSERT (  ( 1 >= ub));       /* WARNING(SDCC_mcs51|SDCC_ds390) */
+}
+#endif
+
+#ifdef TEST4
+void foo(void)
+{
+  volatile struct {
+      signed sb1:1;
+      signed sb3:3;
+    unsigned ub1:1;
+    unsigned ub3:3;
+  } str;
+
+  str.sb1 = -2;                        /* WARNING(SDCC) */
+  str.sb1 = -1;
+  str.sb1 =  1;
+  str.sb1 =  2;                        /* WARNING(SDCC) */
+
+  str.ub1 = -2;                        /* WARNING(SDCC) */
+  str.ub1 = -1;
+  str.ub1 =  1;
+  str.ub1 =  2;                        /* WARNING(SDCC) */
+
+  str.sb3 = -5;                        /* WARNING(SDCC) */
+  str.sb3 = -4;
+  str.sb3 =  7;
+  str.sb3 =  8;                        /* WARNING(SDCC) */
+
+  str.ub3 = -5;                        /* WARNING(SDCC) */
+  str.ub3 = -4;
+  str.ub3 =  7;
+  str.ub3 =  8;                        /* WARNING(SDCC) */
+
+  ASSERT (! (-2 == str.sb1));  /* WARNING */
+  ASSERT (  (-1 == str.sb1));
+  ASSERT (  ( 0 == str.sb1));
+  ASSERT (! ( 1 == str.sb1));  /* WARNING */
+
+  ASSERT (! (-1 == str.ub1));  /* WARNING(SDCC) */
+  ASSERT (  ( 0 == str.ub1));
+  ASSERT (  ( 1 == str.ub1));
+  ASSERT (! ( 2 == str.ub1));  /* WARNING(SDCC) */
+
+  ASSERT (! (-5 == str.sb3));  /* WARNING */
+  ASSERT (  (-4 == str.sb3));
+  ASSERT (  ( 3 == str.sb3));
+  ASSERT (! ( 4 == str.sb3));  /* WARNING */
+
+  ASSERT (! (-1 == str.ub3));  /* WARNING(SDCC) */
+  ASSERT (  ( 0 == str.ub3));
+  ASSERT (  ( 7 == str.ub3));
+  ASSERT (! ( 8 == str.ub3));  /* WARNING(SDCC) */
+}
+#endif