sdcc-3.9.0 fork implementing GNU assembler syntax

This fork aims to provide better support for stm8-binutils

55 files changed, 8500 insertions, 0 deletions

diff --git a/src/regression/Makefile b/src/regression/Makefile
new file mode 100644
index 0000000..26a7ff3
--- /dev/null
+++ b/src/regression/Makefile
@@ -0,0 +1,226 @@
+# Regression testing Makefile for Pic Port of SDCC
+#
+# note that this regression suite was started before
+# the one in sdcc/regression. The regression suite in
+# sdcc/regression is better suited for testing mature
+# ports.
+#
+# GPL'd
+#
+# T. Scott Dattalo scott@dattalo.com
+#
+# This makefile provides a means by which the output
+# of the SDCC Compiler can be tested. This version
+# is unique to the PIC (as in Microchip PIC) port.
+# As such it requires the following software:
+#
+#  gpasm version 0.11.1 (or greater)
+#  gpsim version 0.20.7 (or greater)
+#
+# Usage:
+#
+# make
+#  - without any options the whole regression test is
+#    performed. The results are placed into a log file
+#    (defined by $LOGFILE).
+#
+# make asm
+#  - Creates .asm files by compiling the .c files
+#
+# make cod
+#  - Creates .cod files by assembling the .asm files
+#    (.cod files are symbolic files compatible with
+#    MPASM, Microchip's assembler)
+#
+# make stc
+#  - Creates .stc files which are script files for
+#    gpsim.
+#
+# make clean
+#  - removes all of the intermediate files created
+#
+# make cleancod
+# make cleanasm
+# make cleanstc
+# make cleano
+#  - removes either the .stc, .asm, .cod or .o files
+
+# verboseness
+#Q ?= # be verbose
+Q ?= @ # be quiet
+
+SDCC_SRC=../..
+SDCC_BIN=../..
+
+CC = $(SDCC_BIN)/bin/sdcc
+LINKER = gplink
+USE_PIC16 ?= 0
+ifeq ($(strip $(filter 1 yes,$(USE_PIC16))),)
+TARGETPIC = 16f877
+#TARGETPIC = 16f84
+CFLAGS = -mpic14 -p$(TARGETPIC)
+DIR = pic14
+else
+TARGETPIC = 18f452
+CFLAGS	= -mpic16 -p$(TARGETPIC)
+DIR = pic16
+endif
+CFLAGS += -Wl,-q --no-warn-non-free
+CFLAGS += -Wl,--map
+CFLAGS += -I $(SDCC_SRC)/device/include/$(DIR) -I $(SDCC_SRC)/device/non-free/include/$(DIR)
+CFLAGS += -L $(SDCC_BIN)/device/lib/build/$(DIR) -L $(SDCC_BIN)/device/non-free/lib/build/$(DIR)
+#CFLAGS += --no-pcode-opt
+#CFLAGS += -V
+
+.SUFFIXES: .asm .c .cod .stc
+.NOTPARALLEL:
+
+# Results of the test are placed here:
+LOGFILE = test.log
+
+# Script file for creating gpsim scripts
+CREATESTC = create_stc
+
+# Script file for invoking gpsim
+SIMULATE = simulate
+
+# List the C files to be test here:
+SRC = add.c \
+      add2.c \
+      add3.c \
+      add4.c \
+      and1.c \
+      and2.c \
+      arrays.c \
+      b.c \
+      bank1.c \
+      bool1.c \
+      bool2.c \
+      bool3.c \
+      call1.c \
+      compare.c \
+      compare10.c \
+      compare2.c \
+      compare3.c \
+      compare4.c \
+      compare5.c \
+      compare6.c \
+      compare7.c \
+      compare8.c \
+      compare9.c \
+      configword.c \
+      empty.c \
+      for.c \
+      init0.c \
+      inline.c \
+      mult1.c \
+      nestfor.c \
+      or1.c \
+      pcodeopt.c \
+      pointer1.c \
+      ptrarg.c \
+      ptrfunc.c \
+      rotate1.c \
+      rotate2.c \
+      rotate3.c \
+      rotate4.c \
+      rotate5.c \
+      rotate6.c \
+      rotate7.c \
+      string1.c \
+      struct1.c \
+      sub.c \
+      sub2.c \
+      switch1.c \
+      while.c \
+      xor.c
+
+COD := $(patsubst %.c, %.cod, $(SRC))
+ASM := $(patsubst %.c, %.asm, $(SRC))
+O   := $(patsubst %.c, %.o,   $(SRC))
+P   := $(patsubst %.c, %.p,   $(SRC))
+STC := $(patsubst %.c, %.stc, $(SRC))
+HEX := $(patsubst %.c, %.hex, $(SRC))
+LST := $(patsubst %.c, %.lst, $(SRC))
+MAP := $(patsubst %.c, %.map, $(SRC))
+
+all:	test
+
+
+# The cod files are generated by sdcc
+.c.cod:
+	$(Q)-$(CC) $(CFLAGS) $*.c
+
+# The .stc files are script files for gpsim
+.cod.stc:
+	$(Q)-./$(CREATESTC) $*.cod $*.stc
+	$(Q)-./$(SIMULATE) $*.stc $(LOGFILE)
+
+# this will also make .stc files
+#%.stc : %.cod
+#	./create_stc $^ $@
+
+# now for the dependencies
+
+cod : $(COD)
+
+o : $(O)
+
+asm : $(ASM)
+
+stc : $(STC)
+	echo $(STC)
+
+test:	$(STC)
+	$(Q)echo "Done - Results are in $(LOGFILE)"
+
+cleancod:
+	files="$(COD)" ; \
+	for f in $$files ; do \
+	  if [ -f $$f ]; then rm $$f; fi \
+	done ; \
+
+cleano:
+	files="$(O)" ; \
+	for f in $$files ; do \
+	  if [ -f $$f ]; then rm $$f; fi \
+	done ; \
+
+cleanp:
+	files="$(P)" ; \
+	for f in $$files ; do \
+	  if [ -f $$f ]; then rm $$f; fi \
+	done ; \
+
+cleanasm:
+	files="$(ASM)" ; \
+	for f in $$files ; do \
+	  if [ -f $$f ]; then rm $$f; fi \
+	done ; \
+
+cleanstc:
+	files="$(STC)" ; \
+	for f in $$files ; do \
+	  if [ -f $$f ]; then rm $$f; fi \
+	done ; \
+
+cleanhex:
+	files="$(HEX)" ; \
+	for f in $$files ; do \
+	  if [ -f $$f ]; then rm $$f; fi \
+	done ; \
+
+cleanlst:
+	files="$(LST)" ; \
+	for f in $$files ; do \
+	  if [ -f $$f ]; then rm $$f; fi \
+	done ; \
+
+cleanmap:
+	files="$(MAP)" ; \
+	for f in $$files ; do \
+	  if [ -f $$f ]; then rm $$f; fi \
+	done ; \
+
+clean: cleancod cleanasm cleanstc cleano cleanp cleanhex cleanlst cleanmap
+	if [ -f "$(LOGFILE)" ]; then rm $(LOGFILE); fi
diff --git a/src/regression/add.c b/src/regression/add.c
new file mode 100644
index 0000000..99fce7a
--- /dev/null
+++ b/src/regression/add.c
@@ -0,0 +1,191 @@
+#include "gpsim_assert.h"
+
+// Addition tests
+
+/* bit types are not ANSI - so provide a way of disabling bit types
+ * if this file is used to test other compilers besides SDCC */
+#define SUPPORT_BIT_TYPES 0
+
+/* Some compilers that support bit types do not support bit arithmetic 
+ * (like bitx = bity + bitz;) */
+#define SUPPORT_BIT_ARITHMETIC 1
+
+unsigned char failures=0;
+
+#if SUPPORT_BIT_TYPES
+
+bit bit0 = 0;
+bit bit1 = 0;
+bit bit2 = 0;
+bit bit3 = 0;
+bit bit4 = 0;
+bit bit5 = 0;
+bit bit6 = 0;
+bit bit7 = 0;
+bit bit8 = 0;
+bit bit9 = 0;
+bit bit10 = 0;
+bit bit11 = 0;
+
+#endif
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char achar2 = 0;
+unsigned char achar3 = 0;
+unsigned char *acharP = 0;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void add_lit2uchar(void)
+{
+
+  achar0 = achar0 + 5;
+
+  if(achar0 != 5)
+    failures++;
+
+  achar0 += 10;
+
+  if(achar0 != 15)
+    failures++;
+
+  achar0 = achar0 +1;  // Should be an increment
+  if(achar0 != 16)
+    failures++;
+
+  for(achar1 = 0; achar1 < 100; achar1++)
+    achar0 += 2;
+
+  if(achar0 != 216)
+    failures++;
+
+}
+
+void add_uchar2uchar(void)
+{
+
+  achar1 = achar1 + achar0;
+
+  if(achar1 != 16)
+    failures++;
+
+  for(achar2 = 0; achar2<7; achar2++)
+    achar1 += achar0;
+
+  if(achar1 != 128)
+    failures++;
+
+}
+
+// assumes
+//  achar0 = 0
+//  achar1 = 32
+//  achar2, achar3 can be anything.
+
+void add_uchar2uchar2(void)
+{
+  achar0++;
+  achar0 = achar0 + 1;
+  achar0 = achar0 + 2;
+  achar0 = achar0 + 3;
+  if(achar0 != 7)
+    failures++;
+
+  achar1 += achar0;
+  if(achar1 != 39)
+    failures++;
+
+  achar2 = achar1 + achar0;
+  if(achar2 != 46)
+    failures++;
+
+  achar3 = achar2 + achar1 + achar0;
+  if(achar3 != 92)
+    failures++;
+}
+
+#if SUPPORT_BIT_TYPES
+void add_bits(void)
+{
+  bit1 = bit0;
+
+  bit0 = 1;
+
+  if(bit1 != 0)
+    failures++;
+
+  bit1 = bit1+bit0;
+  if(bit1 != 1)
+    failures++;
+
+#if SUPPORT_BIT_ARITHMETIC
+  bit2 = bit1+bit3;
+  if(!bit2)
+    failures++;
+
+  bit3 = bit4+bit5+bit6+bit7+bit0;
+  if(!bit3)
+    failures++;
+#endif
+}
+#endif
+
+/* add_bit2uchar(void) - assumes bit0 = 1, achar0 = 7  */
+
+#if SUPPORT_BIT_TYPES
+void add_bit2uchar(void)
+{
+  achar0 += bit0;
+
+  if(achar0 != 8)
+    failures++;
+
+  if(achar0 == bit0)
+    failures++;
+}
+
+void add_bit2uint(void)
+{
+  if(aint0 != bit11)
+    failures++;
+
+  aint0 += bit0;
+  if(aint0!=1)
+    failures++;
+}
+#endif
+
+void main(void)
+{
+  add_lit2uchar();
+  ASSERT(MANGLE(failures) == 0);
+
+  achar0=16;
+  achar1=0;
+  add_uchar2uchar();
+  ASSERT(MANGLE(failures) == 0);
+
+
+  achar0 = 0;
+  achar1 = 32;
+  add_uchar2uchar2();
+  ASSERT(MANGLE(failures) == 0);
+
+#if SUPPORT_BIT_TYPES
+  add_bits();
+
+  add_bit2uchar();
+  add_bit2uint();
+#endif
+  ASSERT(MANGLE(failures) == 0);
+
+  done();
+}
diff --git a/src/regression/add2.c b/src/regression/add2.c
new file mode 100644
index 0000000..f9536e4
--- /dev/null
+++ b/src/regression/add2.c
@@ -0,0 +1,326 @@
+#include "gpsim_assert.h"
+
+// Addition tests - mostly int's
+
+/* bit types are not ANSI - so provide a way of disabling bit types
+ * if this file is used to test other compilers besides SDCC */
+#define SUPPORT_BIT_TYPES 0
+
+
+unsigned char failures=0;
+
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned int aint2 = 0;
+unsigned int aint3 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char achar2 = 0;
+unsigned char achar3 = 0;
+unsigned char *acharP = 0;
+
+#if SUPPORT_BIT_TYPES
+
+bit bit0 = 0;
+bit bit1 = 0;
+bit bit2 = 0;
+bit bit3 = 0;
+bit bit4 = 0;
+bit bit5 = 0;
+bit bit6 = 0;
+bit bit7 = 0;
+bit bit8 = 0;
+bit bit9 = 0;
+bit bit10 = 0;
+bit bit11 = 0;
+
+#endif
+
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void add_lit2uint(void)
+{
+
+  aint0 = aint0 + 5;
+
+  if(aint0 != 5)
+    failures++;
+
+  aint0 += 10;
+
+  if(aint0 != 15)
+    failures++;
+
+  aint0 = aint0 +1;  // Should be an increment
+  if(aint0 != 16)
+    failures++;
+
+  for(aint1 = 0; aint1 < 100; aint1++)
+    aint0 += 2;
+
+  if(aint0 != 216)
+    failures++;
+
+}
+
+void add_uint2uint (void)
+{
+
+  aint1 = aint1 + aint0;
+
+  if(aint1 != 16)
+    failures++;
+
+  for(aint2 = 0; aint2<7; aint2++)
+    aint1 += aint0;
+
+  if(aint1 != 128)
+    failures++;
+
+}
+
+// assumes
+//  aint0 = 0
+//  aint1 = 32
+//  aint2, aint3 can be anything.
+
+void add_uint2uint2(void)
+{
+
+
+  aint0++;
+  aint0 = aint0 + 1;
+  aint0 = aint0 + 2;
+  aint0 = aint0 + 3;
+  if(aint0 != 7)
+    failures++;
+
+  aint1 += aint0;
+  if(aint1 != 0x27)
+    failures++;
+
+  aint2 = aint1 + aint0;
+  if(aint2 != 0x2e)
+    failures++;
+
+  aint3 = aint2 + aint1 + aint0;
+  if(aint3 != 0x5c)
+    failures++;
+
+  aint3 += 0xa0;
+  if(aint3 != 0xfc)
+    failures++;
+
+  aint3 += aint0;
+  if(aint3 != 0x103)
+    failures++;
+
+  aint1 += 0xffc0;
+  if(aint1 != 0xffe7)
+    failures++;
+
+  aint3 = aint2 + aint1 + aint0;
+  if(aint3 != 0x1c)
+    failures++;
+
+
+}
+
+#if SUPPORT_BIT_TYPES
+void add_bits(void)
+{
+
+  bit1 = bit0;
+
+  bit0 = 1;
+
+  if(bit1 != 0)
+    failures++;
+
+  bit1 = bit1+bit0;
+  if(bit1 != 1)
+    failures++;
+
+  bit2 = bit1+bit3;
+  if(!bit2)
+    failures++;
+
+  bit3 = bit4+bit5+bit6+bit7+bit0;
+  if(!bit3)
+    failures++;
+}
+#endif
+
+/* add_bit2uchar(void) - assumes bit0 = 1, aint0 = 7  */
+
+#if SUPPORT_BIT_TYPES
+void add_bit2uchar(void)
+{
+
+  achar0 += bit0;
+
+  if(achar0 != 8)
+    failures++;
+
+  if(achar0 == bit0)
+    failures++;
+
+}
+
+void add_bit2uint(void)
+{
+
+  if(aint0 != bit11)
+    failures++;
+
+  aint0 += bit0;
+  if(aint0!=1)
+    failures++;
+
+}
+#endif
+
+/***********************************/
+
+void addlits(void)
+{
+  aint0 += 0x0001;
+
+  if(aint0 != 1)
+    failures++;
+
+  aint0 += 0x00;
+
+  if(aint0 != 1)
+    failures++;
+
+  aint0 += 0x00fe;
+  if(aint0 != 0x00ff)
+    failures++;
+
+  aint0 += 0x0001;
+
+  if(aint0 != 0x0100)
+    failures++;
+
+  aint0++;
+  if(aint0 != 0x0101)
+    failures++;
+
+  aint0 += 0x00ff;
+  if(aint0 != 0x0200)
+    failures++;
+
+  aint0 += 0x00a0;
+  if(aint0 != 0x02a0)
+    failures++;
+
+  aint0 += 0x0061;
+  if(aint0 != 0x0301)
+    failures++;
+
+  aint0 += 0x0100;
+  if(aint0 != 0x0401)
+    failures++;
+
+  aint0 += 0x0101;
+  if(aint0 != 0x0502)
+    failures++;
+
+  aint0 += 0x00fd;
+  if(aint0 != 0x05ff)
+    failures++;
+
+  aint0 += 0x0101;
+  if(aint0 != 0x0700)
+    failures++;
+
+  aint0 += 0x01ff;
+  if(aint0 != 0x08ff)
+    failures++;
+
+  aint0 += 0x01ff;
+  if(aint0 != 0x0afe)
+    failures++;
+
+  aint0 += 0xff02;
+  if(aint0 != 0x0a00)
+    failures++;
+
+  aint0 += 0xffff;
+  if(aint0 != 0x09ff)
+    failures++;
+
+  aint0 += 0xff01;
+  if(aint0 != 0x0900)
+    failures++;
+
+  aint0 += 0xff00;
+  if(aint0 != 0x0800)
+    failures++;
+
+  aint0 += 0xff01;
+  if(aint0 != 0x0701)
+    failures++;
+
+  aint0 += 0x0300;
+  if(aint0 != 0x0a01)
+    failures++;
+
+  aint0 += 0x03ff;
+  if(aint0 != 0x0e00)
+    failures++;
+
+  aint0 += 0x0301;
+  if(aint0 != 0x1101)
+    failures++;
+
+  aint0 += 0x03fe;
+  if(aint0 != 0x14ff)
+    failures++;
+
+  aint0 += 0x0301;
+  if(aint0 != 0x1800)
+    failures++;
+ 
+}
+
+
+void main(void)
+{
+
+  add_lit2uint();
+
+  aint0=16;
+  aint1=0;
+  add_uint2uint();
+
+
+  aint0 = 0;
+  aint1 = 32;
+  aint2 = 0;
+  add_uint2uint2();
+
+#if SUPPORT_BIT_TYPES
+  add_bits();
+
+  achar0 = 7;
+  add_bit2uchar();
+
+  aint0 = 0;
+  bit0 = 1;
+  add_bit2uint();
+#endif
+
+  aint0 = 0;
+  addlits();
+
+  done();
+}
diff --git a/src/regression/add3.c b/src/regression/add3.c
new file mode 100644
index 0000000..a1990af
--- /dev/null
+++ b/src/regression/add3.c
@@ -0,0 +1,218 @@
+#include "gpsim_assert.h"
+
+// Addition tests - mostly int's
+
+/* bit types are not ANSI - so provide a way of disabling bit types
+ * if this file is used to test other compilers besides SDCC */
+#define SUPPORT_BIT_TYPES 0
+
+
+unsigned char failures=0;
+
+
+char char0 = 0;
+char char1 = 0;
+char char2 = 0;
+int int0 = 0;
+int int1 = 0;
+long long0 = 0;
+long long1 = 0;
+unsigned long ulong0 = 0;
+unsigned long ulong1 = 0;
+
+#if SUPPORT_BIT_TYPES
+
+bit bit0 = 0;
+bit bit1 = 0;
+bit bit2 = 0;
+bit bit3 = 0;
+bit bit4 = 0;
+bit bit5 = 0;
+bit bit6 = 0;
+bit bit7 = 0;
+bit bit8 = 0;
+bit bit9 = 0;
+bit bit10 = 0;
+bit bit11 = 0;
+
+#endif
+
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void add_char2char(void)
+{
+  if(char0 != 4)
+    failures++;
+  if(char1 != 5)
+    failures++;
+
+  char0 = char0 + char1;
+
+  if(char0 != 9)
+    failures++;
+
+  char0 += 127;
+  if(char0 > 0)
+    failures++;
+
+  if(char0 != -0x78)
+    failures++;
+
+
+}
+
+void add_compound_char(void)
+{
+  char0 = char1+5;
+
+  if(char0 != 9)
+    failures++;
+
+  if((char0+char1) != 13)
+    failures++;
+}
+
+void add_int2int(void)
+{
+  if(int0 != 4)
+    failures++;
+  if(int1 != 5)
+    failures++;
+
+  int0 += int1;
+  if(int0 != 9)
+    failures++;
+
+  int0 += 0x7fff;
+  if(int0 != -0x7ff8)
+    failures++;
+
+}
+
+void add_compound_int(void)
+{
+  int0 = int1+5;
+
+  if(int0 != 9)
+    failures++;
+
+  if((int0+int1) != 13)
+    failures++;
+}
+
+
+void add_lit2long(void)
+{
+
+  if(long0 != 0)
+    failures++;
+
+  long0++;
+
+  if(long0 != 1)
+    failures++;
+
+  long0 = long0 + 0xff;
+
+  if(long0 != 0x100)
+    failures++;
+
+  long0 = long0 + 0x100;
+  if(long0 != 0x200)
+    failures++;
+
+
+  long0 = long0 + 0xfe00;
+  if(long0 != 0x10000)
+    failures++;
+
+  long0 = long0 + 0xff0000;
+  if(long0 != 0x1000000)
+    failures++;
+
+  long0 = long0 + 0x7e000000;
+  if(long0 != 0x7f000000)
+    failures++;
+
+  /* wrap around zero */
+  long0 = long0 + 0x2000000;
+  if(long0 != -0x7f000000)
+    failures++;
+
+  long0 = long0 + 0x7f000000;
+  if(long0 != 0)
+    failures++;
+
+}
+
+void add_lit2ulong(void)
+{
+
+  if(ulong0 != 0)
+    failures++;
+
+  ulong0++;
+
+  if(ulong0 != 1)
+    failures++;
+
+  ulong0 = ulong0 + 0xff;
+
+  if(ulong0 != 0x100)
+    failures++;
+
+  ulong0 = ulong0 + 0x100;
+  if(ulong0 != 0x200)
+    failures++;
+
+
+  ulong0 = ulong0 + 0xfe00;
+  if(ulong0 != 0x10000)
+    failures++;
+
+  ulong0 = ulong0 + 0xff0000;
+  if(ulong0 != 0x1000000)
+    failures++;
+
+  ulong0 = ulong0 + 0x7e000000;
+  if(ulong0 != 0x7f000000)
+    failures++;
+
+  ulong0 = ulong0 + 0x2000000;
+  if(ulong0 != 0x81000000)
+    failures++;
+
+  /* wrap around zero */
+  ulong0 = ulong0 + 0x7f000000;
+  if(ulong0)
+    failures++;
+
+}
+
+void main(void)
+{
+  char0=4;
+  char1 = char0 + 1;
+  add_char2char();
+
+  char1=4;
+  add_compound_char();
+
+  int0 = 4;
+  int1 = int0 + 1;
+  add_int2int();
+
+  int1=4;
+  add_compound_int();
+
+  add_lit2long();
+  add_lit2ulong();
+
+  done();
+}
diff --git a/src/regression/add4.c b/src/regression/add4.c
new file mode 100644
index 0000000..ca370c5
--- /dev/null
+++ b/src/regression/add4.c
@@ -0,0 +1,82 @@
+#include "gpsim_assert.h"
+
+unsigned char failures = 0;
+
+//bit bit0 = 0;
+int int0 = 0;
+int int1 = 0;
+char char0 = 0;
+char char1 = 0;
+long long0 = 0;
+long long1 = 0;
+unsigned long ulong0 = 0;
+unsigned long ulong1 = 0;
+#define NULL 0
+char *cP0=NULL;
+char *cP1=NULL;
+int *iP0=NULL;
+int *iP1=NULL;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+/* pointer to char arithmetic */
+
+void pc_add(void)
+{
+
+  if(*cP1)
+    failures++;
+
+  *cP1 += 1;
+  if(*cP1 != 1)
+    failures++;
+
+  if(char0 != 1)
+    failures++;
+
+  char0++;
+
+  if(*cP1 != 2)
+    failures++;
+
+  char1 = char0 + *cP1;
+
+  if(char1 != 4)
+    failures++;
+}
+
+/* pointer to integer arithmetic */
+void pi_add(void)
+{
+  if(*iP0)
+    failures++;
+
+  *iP0 += 1;
+
+  if(*iP0 != 1)
+    failures++;
+
+  if(int0 != 1)
+    failures++;
+
+  int1 = int0 + *iP0;
+  if(int1 != 2)
+    failures++;
+}
+
+void main(void)
+{
+
+  cP1 = &char0;
+  pc_add();
+
+  iP0 = &int0;
+  pi_add();
+
+  done();
+}
diff --git a/src/regression/and1.c b/src/regression/and1.c
new file mode 100644
index 0000000..bf9ecae
--- /dev/null
+++ b/src/regression/and1.c
@@ -0,0 +1,141 @@
+#include "gpsim_assert.h"
+
+unsigned char failures=0;
+
+
+unsigned int uint0 = 0;
+unsigned int uint1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+unsigned long ulong0 = 0;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+// uchar0 = 0xff;
+void and_lit2uchar(void)
+{
+
+  if(uchar0 != 0xff)
+    failures++;
+
+  uchar0 &= 0x7f;
+
+  if(uchar0 != 0x7f)
+    failures++;
+
+  uchar0 &= 0x3f;
+
+  if(uchar0 != 0x3f)
+    failures++;
+
+  uchar0 &= 0xdf;
+
+  if(uchar0 != 0x1f)
+    failures++;
+}
+
+void and_lit2uint(void)
+{
+  if(uint0 != 0xffff)
+    failures++;
+
+  uint0 &= 0x7fff;
+
+  if(uint0 != 0x7fff)
+    failures++;
+
+  uint0 &= 0x3fff;
+
+  if(uint0 != 0x3fff)
+    failures++;
+
+  uint0 &= 0xdfff;
+
+  if(uint0 != 0x1fff)
+    failures++;
+
+
+  uint0 &= 0xff7f;
+
+  if(uint0 != 0x1f7f)
+    failures++;
+
+  uint0 &= 0x0f0f;
+
+  if(uint0 != 0x0f0f)
+    failures++;
+
+  uint0 &= 0xfefe;
+
+  if(uint0 != 0x0e0e)
+    failures++;
+
+  uint0 &= 0xf0f0;
+
+  if(uint0 != 0)
+    failures++;
+}
+
+void and_lit2ulong(void)
+{
+
+  if(ulong0 != 0xffffffff)
+    failures++;
+
+  ulong0 &= 0x7fffffff;
+
+  if(ulong0 != 0x7fffffff)
+    failures++;
+
+  ulong0 &= 0xff00ffff;
+
+  if(ulong0 != 0x7f00ffff)
+    failures++;
+
+  ulong0 &= 0xfeff00ff;
+
+  if(ulong0 != 0x7e0000ff)
+    failures++;
+}
+
+/*-----------*/
+void and_uchar2uchar(void)
+{
+
+  uchar0 &= uchar1;
+
+  if(uchar0 != 0x0f)
+    failures++;
+
+  uchar1 &= 0xf7;
+
+  uchar0 = uchar1 & 0xfe;
+
+  if(uchar0 != 0x06)
+    failures++;
+
+}
+
+void main(void)
+{
+
+  uchar0 = 0xff;
+  and_lit2uchar();
+
+  uint0 = 0xffff;
+  and_lit2uint();
+
+  ulong0 = 0xffffffff;
+  and_lit2ulong();
+
+  uchar0 = 0xff;
+  uchar1 = 0x0f;
+  and_uchar2uchar();
+
+  done();
+}
diff --git a/src/regression/and2.c b/src/regression/and2.c
new file mode 100644
index 0000000..c667bad
--- /dev/null
+++ b/src/regression/and2.c
@@ -0,0 +1,115 @@
+#include "gpsim_assert.h"
+
+unsigned char failures=0;
+
+
+unsigned int uint0 = 0;
+unsigned int uint1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+unsigned long ulong0 = 0;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+// uchar0 = 0x13;
+void and_compound1(void)
+{
+  uchar0 = (uchar0 + 1) & 0x0f;
+  if(uchar0 != 4)
+    failures++;
+}
+
+
+// uchar1 = 0x42;
+void and_compound2(void)
+{
+  uchar0 = (uchar1 + 1) & 0x0f;
+  if(uchar0 != 3)
+    failures++;
+
+  if(uchar1 != 0x42)
+    failures++;
+}
+
+// uchar0 = 0x13;
+void or_compound1(void)
+{
+  uchar0 = (uchar0 + 0xe) | 0x0f;
+  if(uchar0 != 0x2f)
+    failures++;
+}
+
+
+// uchar1 = 0x47;
+void or_compound2(void)
+{
+  uchar0 = (uchar1 + 0xf) | 0x0f;
+  if(uchar0 != 0x5f)
+    failures++;
+
+  if(uchar1 != 0x47)
+    failures++;
+}
+
+
+
+// uchar0 = 0x13;
+void xor_compound1(void)
+{
+  uchar0 = (uchar0 + 1) ^ 0x0f;
+  if(uchar0 != 0x1b)
+    failures++;
+}
+
+
+// uchar1 = 0x47;
+void xor_compound2(void)
+{
+  uchar0 = (uchar1 + 0xf) ^ 0x0f;
+  if(uchar0 != 0x59)
+    failures++;
+
+  if(uchar1 != 0x47)
+    failures++;
+}
+
+// uchar0 = 0x13;
+void neg_compound1(void)
+{
+  uchar0 = ~(uchar0 + 1);
+  if(uchar0 != 0xeb)
+    failures++;
+}
+
+
+void main(void)
+{
+
+  uchar0 = 0x13;
+  and_compound1();
+
+  uchar1 = 0x42;
+  and_compound2();
+
+  uchar0 = 0x13;
+  or_compound1();
+
+  uchar1 = 0x47;
+  or_compound2();
+
+  uchar0 = 0x13;
+  xor_compound1();
+
+  uchar1 = 0x47;
+  xor_compound2();
+
+  uchar0 = 0x13;
+  neg_compound1();
+
+  done();
+}
diff --git a/src/regression/arrays.c b/src/regression/arrays.c
new file mode 100644
index 0000000..8877692
--- /dev/null
+++ b/src/regression/arrays.c
@@ -0,0 +1,145 @@
+#include "gpsim_assert.h"
+
+unsigned char failures = 0;
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void
+bool_or1 (void)
+{
+
+  if ((achar0 > 0) || (achar1 > 0))
+    failures++;
+}
+
+void
+bool_or2 (void)
+{
+
+  if (achar0 || achar1)
+    failures++;
+}
+
+void
+bool_test1 (void)
+{
+
+  if ((achar0 == 0) || achar1)
+    failures++;
+}
+
+
+void
+bool_test2 (void)
+{
+
+  if ((achar0 == 0) || aint0)
+    failures++;
+}
+
+void
+bool_and1 (void)
+{
+
+  if (achar0 && achar1)
+    failures++;
+}
+
+void
+bin_or1 (void)
+{
+
+  char t;
+
+  t = achar0 | achar1;
+  if (t)
+    failures++;
+}
+
+void
+bin_xor1 (void)
+{
+
+  if (achar0 ^ achar1)
+    failures++;
+}
+
+
+void
+bool_test3 (void)
+{
+
+  if ((achar0 == 0x42) || (achar1 == 42))
+    failures++;
+}
+
+
+void
+bool_or_lit1 (void)
+{
+
+  achar0 |= 0x0f;
+
+  if (achar0 > 0x10)
+    failures++;
+
+  if ((achar0 | 0x10) > 0xf0)
+    failures++;
+
+}
+
+void
+bool_and_lit1 (void)
+{
+
+  achar0 &= 0xf0;
+
+  if (achar0 > 0x10)
+    failures++;
+
+  if ((achar0 & 0x10) > 0xf0)
+    failures++;
+
+  achar0 &= 0xef;
+
+}
+
+void
+main (void)
+{
+
+  bool_or1 ();
+  bool_or2 ();
+  bool_and1 ();
+  bin_or1 ();
+  bin_xor1 ();
+
+  achar0++;
+  bool_and1 ();
+  bool_test1 ();
+  bool_test2 ();
+  bool_test3 ();
+
+
+  achar0--;
+  achar1++;
+  bool_and1 ();
+
+  achar0 = 0;
+  achar1 = 0;
+
+  bool_or_lit1 ();
+  bool_and_lit1 ();
+
+  done ();
+}
diff --git a/src/regression/b.c b/src/regression/b.c
new file mode 100644
index 0000000..dd45f6c
--- /dev/null
+++ b/src/regression/b.c
@@ -0,0 +1,64 @@
+#include "gpsim_assert.h"
+
+unsigned char failures = 0;
+
+unsigned char uchar0=0;
+unsigned char uchar1=0;
+unsigned char uchar2=0;
+
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+/*
+void incptr(unsigned char *ucP)
+{
+  *ucP = *ucP + 1;
+}
+*/
+
+void inc(unsigned char k)
+{
+  uchar0 = uchar0 + k;
+}
+
+void f1(void)
+{
+
+  uchar2++;
+}
+
+void nested_call(unsigned char u)
+{
+
+  f1();
+  uchar1 = uchar1 + u;
+  inc(uchar1);
+
+}
+  //  uchar1 = uchar1 + uchar0;
+  //  uchar2 = uchar1 + k;
+
+void main(void)
+{
+
+  uchar0=1;
+  //incptr(&uchar0);
+  inc(uchar0);
+  if(uchar0 !=2)
+    failures++;
+
+  uchar0 = 2;
+  uchar1 = 1;
+  uchar2 = 1;
+  nested_call(uchar2);
+
+  if(uchar0 !=4)
+    failures++;
+
+  done();
+}
diff --git a/src/regression/bank1.c b/src/regression/bank1.c
new file mode 100644
index 0000000..3c58189
--- /dev/null
+++ b/src/regression/bank1.c
@@ -0,0 +1,51 @@
+#include "gpsim_assert.h"
+
+#if SUPPORT_BIT_TYPES
+# define bit bit
+#else
+# define bit unsigned char
+#endif
+
+unsigned char success=0;
+unsigned char failures=0;
+unsigned char dummy=0;
+unsigned bit bit1;
+
+typedef unsigned char byte;
+
+byte d2;
+
+unsigned char uchar0 = 0xa5;
+
+__data __at (0xa0) unsigned char uc_bank1_temp = 0x42;
+__data __at (0xa2) unsigned int  ui_bank1_temp = 3;
+
+void
+done(void)
+{
+  dummy++;
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void main(void)
+{
+  dummy = 0;
+  ui_bank1_temp = 0;
+  uc_bank1_temp = 0;
+
+  bit1 = 0;
+
+  uchar0 = (uchar0<<4) | (uchar0>>4);
+
+  if(uchar0 > 7) {
+    dummy = 8;
+    uc_bank1_temp = failures;
+  }
+
+  if(uc_bank1_temp > 3)
+    bit1 = 1;
+
+  success = failures;
+  done();
+}
diff --git a/src/regression/bool1.c b/src/regression/bool1.c
new file mode 100644
index 0000000..46857bf
--- /dev/null
+++ b/src/regression/bool1.c
@@ -0,0 +1,133 @@
+#include "gpsim_assert.h"
+
+unsigned char failures=0;
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void bool_or1(void)
+{
+
+  if( (achar0 >0) || (achar1 >0 ))
+    failures++;
+}
+
+void bool_or2(void)
+{
+
+  if( achar0 || achar1)
+    failures++;
+}
+
+void bool_test1(void)
+{
+
+  if( (achar0==0) || achar1)
+    failures++;
+}
+
+
+void bool_test2(void)
+{
+
+  if( (achar0==0) || aint0)
+    failures++;
+}
+
+void bool_and1(void)
+{
+
+  if( achar0 && achar1)
+    failures++;
+}
+
+void bin_or1(void)
+{
+
+  char t;
+
+  t = achar0 | achar1;
+  if(t)
+    failures++;
+}
+
+void bin_xor1(void)
+{
+
+  if(achar0 ^ achar1)
+    failures++;
+}
+
+
+void bool_test3(void)
+{
+
+  if((achar0 == 0x42) || (achar1 == 42))
+    failures++;
+}
+
+
+void bool_or_lit1(void)
+{
+
+  achar0 |= 0x0f;
+
+  if(achar0 > 0x10)
+    failures++;
+
+  if( (achar0 | 0x10) > 0xf0)
+    failures++;
+
+}
+
+void bool_and_lit1(void)
+{
+
+  achar0 &= 0xf0;
+
+  if(achar0 > 0x10)
+    failures++;
+
+  if( (achar0 & 0x10) > 0xf0)
+    failures++;
+
+  achar0 &= 0xef;
+
+}
+
+void main(void)
+{
+
+  bool_or1();
+  bool_or2();
+  bool_and1();
+  bin_or1();
+  bin_xor1();
+
+  achar0++;
+  bool_and1();
+  bool_test1();
+  bool_test2();
+  bool_test3();
+
+
+  achar0--; achar1++;
+  bool_and1();
+
+  achar0=0;
+  achar1=0;
+
+  bool_or_lit1();
+  bool_and_lit1();
+
+  done();
+}
diff --git a/src/regression/bool2.c b/src/regression/bool2.c
new file mode 100644
index 0000000..3289d7c
--- /dev/null
+++ b/src/regression/bool2.c
@@ -0,0 +1,50 @@
+#include "gpsim_assert.h"
+
+unsigned char failures=0;
+
+#if SUPPORT_BIT_TYPES
+# define bit bit
+#else
+# define bit unsigned char
+#endif
+
+bit bit0 = 0;
+bit bit1 = 0;
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void bit_invert(void)
+{
+
+  bit0 = !bit0;
+  bit1 = !bit1;
+
+  if((bit0 != bit1) || (bit0 == 0))
+    failures++;
+    
+}
+
+void bit_copy(void)
+{
+
+  bit0 = !bit0;
+  bit1 = bit0;
+}
+
+void main(void)
+{
+
+  bit_invert();
+  bit_copy();
+
+  done();
+}
diff --git a/src/regression/bool3.c b/src/regression/bool3.c
new file mode 100644
index 0000000..d3092da
--- /dev/null
+++ b/src/regression/bool3.c
@@ -0,0 +1,65 @@
+#include "gpsim_assert.h"
+
+
+/* Compound comparisons */
+
+
+unsigned char failures=0;
+
+unsigned int ui0 = 0;
+unsigned int ui1 = 0;
+unsigned char uc0 = 0;
+unsigned char uc1 = 0;
+unsigned long uL0 = 0;
+unsigned long uL1 = 0;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void compound_compare_uc(void)
+{
+
+  failures += (uc0 != uc1);
+
+}
+
+
+void compound_compare_ui(void)
+{
+
+  failures += (ui0 != ui1);
+
+}
+
+void compound_compare_ul(void)
+{
+
+  failures += (uL0 != uL1);
+
+}
+
+void compound_compare_uc_lit(void)
+{
+
+  failures += (uc0 != 0xff);
+  failures += (uc0 != 0xff);
+  failures += (uc0 == 0);
+
+}
+
+void main(void)
+{
+
+  compound_compare_uc();
+  compound_compare_ui();
+  compound_compare_ul();
+
+  uc0 = 0xff;
+  compound_compare_uc_lit();
+
+  done();
+}
diff --git a/src/regression/call1.c b/src/regression/call1.c
new file mode 100644
index 0000000..f64a026
--- /dev/null
+++ b/src/regression/call1.c
@@ -0,0 +1,157 @@
+#include "gpsim_assert.h"
+
+unsigned char failures = 0;
+
+unsigned int uint0 = 0;
+unsigned int uint1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+
+unsigned char call3 (void);
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void
+call1 (unsigned char uc0)
+{
+  if (uc0)
+    failures++;
+}
+
+void
+call2 (unsigned int ui0)
+{
+  if (ui0)
+    failures++;
+
+}
+
+unsigned char
+call3 (void)
+{
+  if (uchar0)
+    failures++;
+
+  return (failures);
+
+}
+
+unsigned int
+call4 (void)
+{
+  unsigned int i = 0;
+
+  if (uint0)
+    i++;
+
+  return (i);
+
+}
+
+unsigned int
+call5 (unsigned int k)
+{
+
+  if (k)
+    failures++;
+
+  return (k);
+
+}
+
+unsigned char 
+call6a(unsigned char uc)
+{
+
+  if(uc>uchar1)
+    return 1;
+  else
+    return 0;
+
+}
+
+unsigned char
+call6(unsigned char uc)
+{
+
+  return(call6a(uc));
+}
+
+unsigned int 
+call7a(unsigned int ui)
+{
+  if(ui)
+    return 1;
+  else
+    return 0;
+
+}
+
+unsigned int
+call7(unsigned int ui)
+{
+
+  return(call7a(ui));
+}
+
+unsigned char
+call8(unsigned char uc1,unsigned char uc2)
+{
+
+  return uc1+uc2;
+}
+
+void call9(unsigned int ui1, unsigned int ui2)
+{
+
+  if(ui1 != 0x1234)
+    failures++;
+  if(ui2 != 0x5678)
+    failures++;
+
+}
+
+void
+main (void)
+{
+
+  call1 (uchar0);
+  call2 (uint0);
+  uchar1 = call3 ();
+  uint1 = call4 ();
+  if (uint1)
+    failures++;
+
+  uint1 = call5 (uint0);
+  if (uint1)
+    failures++;
+
+  if(call6(uchar0))
+    failures++;
+
+
+  if(call7(0))
+    failures++;
+
+  if(!call7(1))
+    failures++;
+
+  if(!call7(0xff00))
+    failures++;
+
+  uchar0=4;
+  uchar1=3;
+  uchar0 = call8(uchar0,uchar1);
+
+  if(uchar0 != 7)
+    failures++;
+
+  call9(0x1234,0x5678);
+
+  done ();
+}
diff --git a/src/regression/compare.c b/src/regression/compare.c
new file mode 100644
index 0000000..29843f4
--- /dev/null
+++ b/src/regression/compare.c
@@ -0,0 +1,186 @@
+#include "gpsim_assert.h"
+/*
+
+   PIC PORT Test code
+
+ */
+
+/*
+   compare.c test compare
+
+ */
+
+unsigned char failures = 0;
+
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+
+char schar0 = 0;
+char schar1 = 0;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+/* achar0 should be zero */
+
+void
+compare_char_to_lits1 (void)
+{
+
+  if (achar0)
+    failures++;
+
+  if (achar0 == 1)
+    failures++;
+
+  if (achar0 == 7)
+    failures++;
+
+  if (achar0 != 0)
+    failures++;
+}
+
+/* achar0 should be `5' */
+void
+compare_char_to_lits2 (void)
+{
+
+  if (!achar0)
+    failures++;
+
+  if (achar0 == 1)
+    failures++;
+
+  if (achar0 == 7)
+    failures++;
+
+  if (achar0 != 5)
+    failures++;
+}
+
+
+/* achar0 should equal achar1 */
+void
+compare_char_to_char1 (void)
+{
+
+  if (achar0 != achar1)
+    failures++;
+
+  if (schar0 != schar1)
+    failures++;
+}
+
+/* achar0 should be different than achar1 */
+void
+compare_char_to_char2 (void)
+{
+
+  if (achar0 == achar1)
+    failures++;
+
+}
+
+/* aint0 should be zero */
+
+void
+compare_int_to_lits1 (void)
+{
+
+  if (aint0)
+    failures++;
+
+  if (aint0 == 1)
+    failures++;
+
+  if (aint0 == 7)
+    failures++;
+
+  if (aint0 != 0)
+    failures++;
+}
+
+/* aint0 should be `5' */
+void
+compare_int_to_lits2 (void)
+{
+
+  if (!aint0)
+    failures++;
+
+  if (aint0 == 1)
+    failures++;
+
+  if (aint0 == 7)
+    failures++;
+
+  if (aint0 != 5)
+    failures++;
+}
+
+/* aint0 should be `0x1234' */
+void
+compare_int_to_lits3 (void)
+{
+
+  if (!aint0)
+    failures++;
+
+  if (aint0 == 1)
+    failures++;
+
+  if (aint0 == 7)
+    failures++;
+
+  if (aint0 != 0x1234)
+    failures++;
+}
+
+/* aint0 should equal aint1 */
+void
+compare_int_to_int1 (void)
+{
+
+  if (aint0 != aint1)
+    failures++;
+
+}
+
+/* aint0 should be different than aint1 */
+void
+compare_int_to_int2 (void)
+{
+
+  if (aint0 == aint1)
+    failures++;
+
+}
+
+void
+main (void)
+{
+
+  compare_char_to_lits1 ();
+  compare_char_to_char1 ();
+  achar0 = 5;
+  compare_char_to_lits2 ();
+  compare_char_to_char2 ();
+
+
+  compare_int_to_lits1 ();
+  aint0 = 5;
+  compare_int_to_lits2 ();
+  aint0 = 0x1234;
+  compare_int_to_lits3 ();
+  compare_int_to_int2 ();
+  aint0 = 0;
+  compare_int_to_int1 ();
+
+  done ();
+}
diff --git a/src/regression/compare10.c b/src/regression/compare10.c
new file mode 100644
index 0000000..b3ed5cb
--- /dev/null
+++ b/src/regression/compare10.c
@@ -0,0 +1,322 @@
+#include "gpsim_assert.h"
+#include "picregs.h"
+
+// Signed comparisons of the form:  (variable>=LIT)
+//
+// This regression test exercises all of the boundary
+// conditions in literal less than comparisons. There
+// are numerous opportunities to optimize these comparison
+// and each one has an astonishing capability of failing
+// a boundary condition.
+
+unsigned char failures = 0;
+unsigned char result = 0;
+
+//bit bit0 = 0;
+int int0 = 0;
+int int1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+signed char char0 = 0;
+signed char char1 = 0;
+char long0 = 0;
+char long1 = 0;
+
+/* *** NOTE ***  This particular test takes quite a while to run 
+ * ~ 10,000,000 instruction cycles. (2.5 seconds on a 20Mhz PIC).
+ * The WDT will reset the CPU if it's enabled. So disable it...
+*/
+
+typedef unsigned int word;
+
+//word at 0x2007  CONFIG = wdt_off & pwrte_on;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+
+void c_char_gte_lit1(unsigned char expected_result)
+{
+  result = 0;
+
+  if(char0 >= -0x7f)
+    result |= 1;
+
+
+  if(char0 >= -1)
+    result |= 2;
+
+  if(char0 >= 0)
+    result |= 4;
+
+  if(char0 >= 1)
+    result |= 8;
+
+  if(char0 >= 0x7e)
+    result |= 0x10;
+  
+  if(char0 >= 0x7f)
+    result |= 0x20;
+  
+  if(result != expected_result)
+    failures++;
+}
+
+
+void char_compare(void)
+{
+  char0 = 0x7f;
+  c_char_gte_lit1(0x3f);
+
+  char0 = 0x7e;
+  c_char_gte_lit1(0x1f);
+
+  char0 = 0x40;
+  c_char_gte_lit1(0x0f);
+
+  char0 = 0x2;
+  c_char_gte_lit1(0x0f);
+
+  char0 = 0x1;
+  c_char_gte_lit1(0x0f);
+
+  char0 = 0;
+  c_char_gte_lit1(0x07);
+
+  char0 = -1;
+  c_char_gte_lit1(0x03);
+
+  char0 = -2;
+  c_char_gte_lit1(0x01);
+
+  char0 = -0x40;
+  c_char_gte_lit1(0x01);
+
+  char0 = -0x7e;
+  c_char_gte_lit1(0x01);
+
+  char0 = -0x7f;
+  c_char_gte_lit1(0x01);
+
+  char0 = 0x80;
+  c_char_gte_lit1(0x00);
+
+
+  /* Now test entire range */
+
+  for(char0=1; char0 != 0x7e; char0++)
+    c_char_gte_lit1(0x0f);
+
+  for(char0=-0x7f; char0 != -1; char0++)
+    c_char_gte_lit1(0x01);
+
+}
+
+
+void c_int_gte_lit1(unsigned char expected_result)
+{
+  result = 0;
+
+  if(int0 >= 0)
+    result |= 1;
+
+  if(int0 >= 1)
+    result |= 2;
+
+
+  if(int0 >= 0xff)
+    result |= 4;
+
+  if(int0 >= 0x100)
+    result |= 8;
+
+  if(int0 >= 0x0101)
+    result |= 0x10;
+  
+  if(int0 >= 0x01ff)
+    result |= 0x20;
+  
+  if(int0 >= 0x0200)
+    result |= 0x40;
+
+  if(int0 >= 0x0201)
+    result |= 0x80;
+
+  if(result != expected_result)
+    failures=1;
+
+}
+
+
+void int_compare1(void)
+{
+  int0 = -1;
+  c_int_gte_lit1(0x00);
+
+  int0 = 0;
+  c_int_gte_lit1(0x01);
+
+  int0 = 1;
+  c_int_gte_lit1(0x03);
+
+  int0 = 2;
+  c_int_gte_lit1(0x03);
+
+  int0 = 0xfe;
+  c_int_gte_lit1(0x03);
+
+  int0 = 0xff;
+  c_int_gte_lit1(0x07);
+
+  int0 = 0x100;
+  c_int_gte_lit1(0x0f);
+
+  int0 = 0x101;
+  c_int_gte_lit1(0x1f);
+
+  int0 = 0x102;
+  c_int_gte_lit1(0x1f);
+
+  int0 = 0x1fe;
+  c_int_gte_lit1(0x1f);
+
+  int0 = 0x1ff;
+  c_int_gte_lit1(0x3f);
+
+  int0 = 0x200;
+  c_int_gte_lit1(0x7f);
+
+  int0 = 0x201;
+  c_int_gte_lit1(0xff);
+
+  int0 = 0x7f00;
+  c_int_gte_lit1(0xff);
+
+  /* now check contiguous ranges */
+
+  for(int0 = -0x7fff; int0 != -1; int0++)
+    c_int_gte_lit1(0x00);
+
+  for(int0 = 1; int0 != 0xff; int0++)
+    c_int_gte_lit1(0x03);
+
+  for(int0 = 0x201; int0 != 0x7fff; int0++)
+    c_int_gte_lit1(0xff);
+
+}
+
+
+void c_int_gte_lit2(unsigned char expected_result)
+{
+  result = 0;
+
+  if(int0 >= -0x7fff)
+    result |= 1;
+
+  if(int0 >= -0x7f00)
+    result |= 2;
+
+  if(int0 >= -0x7eff)
+    result |= 4;
+
+  if(int0 >= -0x7e00)
+    result |= 8;
+
+  if(int0 >= -0x0101)
+    result |= 0x10;
+  
+  if(int0 >= -0x0100)
+    result |= 0x20;
+  
+  if(int0 >= -0xff)
+    result |= 0x40;
+
+  if(int0 >= -1)
+    result |= 0x80;
+
+  if(result != expected_result)
+    failures=1;
+}
+
+void int_compare2(void)
+{
+  int0 = -0x7fff;
+  c_int_gte_lit2(0x01);
+
+  int0 = -0x7f00;
+  c_int_gte_lit2(0x03);
+
+  int0 = -0x7eff;
+  c_int_gte_lit2(0x07);
+
+  int0 = -0x7e00;
+  c_int_gte_lit2(0x0f);
+
+  int0 = -0x7dff;
+  c_int_gte_lit2(0x0f);
+
+  int0 = -0x4567;
+  c_int_gte_lit2(0x0f);
+
+  int0 = -0x200;
+  c_int_gte_lit2(0x0f);
+
+  int0 = -0x102;
+  c_int_gte_lit2(0x0f);
+
+  int0 = -0x101;
+  c_int_gte_lit2(0x1f);
+
+  int0 = -0x100;
+  c_int_gte_lit2(0x3f);
+
+  int0 = -0xff;
+  c_int_gte_lit2(0x7f);
+
+  int0 = -0x02;
+  c_int_gte_lit2(0x7f);
+
+  int0 = -0x01;
+  c_int_gte_lit2(0xff);
+
+  int0 = 0;
+  c_int_gte_lit2(0xff);
+
+  int0 = 1;
+  c_int_gte_lit2(0xff);
+
+  int0 = 0x7fff;
+  c_int_gte_lit2(0xff);
+
+  /* now check contiguous ranges */
+
+  for(int0 = -0x7fff; int0 != -0x7f00; int0++)
+    c_int_gte_lit2(0x01);
+
+  for(int0 = -0x7e00; int0 != -0x101; int0++)
+    c_int_gte_lit2(0x0f);
+
+  for(int0 = -1; int0 != 0x7fff; int0++)
+    c_int_gte_lit2(0xff);
+
+}
+
+
+
+
+void
+main (void)
+{
+  char_compare();
+  __asm clrwdt __endasm;
+  int_compare1();
+  __asm clrwdt __endasm;
+  int_compare2();
+  __asm clrwdt __endasm;
+
+  done ();
+}
diff --git a/src/regression/compare2.c b/src/regression/compare2.c
new file mode 100644
index 0000000..d14aeb0
--- /dev/null
+++ b/src/regression/compare2.c
@@ -0,0 +1,362 @@
+#include "gpsim_assert.h"
+
+unsigned char failures = 0;
+unsigned char dummy = 0;
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void
+char_lt_char (void)
+{
+  if (achar0 < achar1)
+    failures++;
+}
+
+void
+char_gt_char (void)
+{
+  if (achar1 > achar0)
+    failures++;
+}
+
+void
+char_lte_char (void)
+{
+  if (achar0 <= achar1)
+    failures++;
+}
+
+void
+char_gte_char (void)
+{
+  if (achar1 >= achar0)
+    failures++;
+}
+
+void
+char_lt_lit (void)
+{
+  if (achar1 < 0x10)
+    failures++;
+}
+
+void
+char_gt_lit (void)
+{
+  if (achar1 > 0x10)
+    failures++;
+}
+
+void
+char_lte_lit (void)
+{
+  if (achar1 <= 0x0f)
+    failures++;
+}
+
+void
+char_gte_lit (void)
+{
+  if (achar1 >= 0x11)
+    failures++;
+}
+
+
+/* now repeat test using negative logic */
+void
+char_lt_char_else (void)
+{
+  if (achar0 >= achar1)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+char_gt_char_else (void)
+{
+  if (achar1 <= achar0)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+char_lte_char_else (void)
+{
+  if (achar0 > achar1)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+char_gte_char_else (void)
+{
+  if (achar1 < achar0)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+char_lt_lit_else (void)
+{
+  if (achar1 >= 0x10)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+char_gt_lit_else (void)
+{
+  if (achar1 <= 0x10)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+char_lte_lit_else (void)
+{
+  if (achar1 > 0x0f)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+char_gte_lit_else (void)
+{
+  if (achar1 < 0x11)
+    dummy++;
+  else
+    failures++;
+}
+
+
+/* ints */
+
+void
+int_lt_int (void)
+{
+  if (aint0 < aint1)
+    failures++;
+}
+
+void
+int_gt_int (void)
+{
+  if (aint1 > aint0)
+    failures++;
+}
+
+void
+int_lte_int (void)
+{
+  if (aint0 <= aint1)
+    failures++;
+}
+
+void
+int_gte_int (void)
+{
+  if (aint1 >= aint0)
+    failures++;
+}
+
+void
+int_lt_lit (void)
+{
+  if (aint1 < 0x10)
+    failures++;
+}
+
+void
+int_gt_lit (void)
+{
+  if (aint1 > 0x10)
+    failures++;
+}
+
+void
+int_lte_lit (void)
+{
+  if (aint1 <= 0x0f)
+    failures++;
+}
+
+void
+int_gte_lit (void)
+{
+  if (aint1 >= 0x11)
+    failures++;
+}
+
+
+
+
+/* now repeat int comparisons using negative logic */
+
+void
+int_lt_int_else (void)
+{
+  if (aint0 >= aint1)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+int_gt_int_else (void)
+{
+  if (aint1 <= aint0)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+int_lte_int_else (void)
+{
+  if (aint0 > aint1)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+int_gte_int_else (void)
+{
+  if (aint1 < aint0)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+int_lt_lit_else (void)
+{
+  if (aint1 >= 0x10)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+int_gt_lit_else (void)
+{
+  if (aint1 <= 0x10)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+int_lte_lit_else (void)
+{
+  if (aint1 > 0x0f)
+    dummy++;
+  else
+    failures++;
+}
+
+void
+int_gte_lit_else (void)
+{
+  if (aint1 < 0x11)
+    dummy++;
+  else
+    failures++;
+}
+
+
+
+
+
+
+void
+main (void)
+{
+
+  char_lt_char ();
+  char_gt_char ();
+
+  achar0++;
+  char_lt_char ();
+  char_gt_char ();
+  char_gte_char ();
+  char_lte_char ();
+
+  achar1 = 0x10;
+  char_lt_lit ();
+  char_gt_lit ();
+  char_lte_lit ();
+  char_gte_lit ();
+
+
+  achar0 = 0;
+  achar1 = 0;
+
+  char_lt_char_else ();
+  char_gt_char_else ();
+
+  achar0++;
+  char_lt_char_else ();
+  char_gt_char_else ();
+  char_gte_char_else ();
+  char_lte_char_else ();
+
+  achar1 = 0x10;
+  char_lt_lit_else ();
+  char_gt_lit_else ();
+  char_lte_lit_else ();
+  char_gte_lit_else ();
+
+
+
+  int_lt_int ();
+  int_gt_int ();
+
+  aint0++;
+  int_lt_int ();
+  int_gt_int ();
+  int_gte_int ();
+  int_lte_int ();
+
+  aint1 = 0x10;
+  int_lt_lit ();
+  int_gt_lit ();
+  int_lte_lit ();
+  int_gte_lit ();
+
+  aint0=0;
+  aint1=0;
+  int_lt_int_else ();
+  int_gt_int_else ();
+
+  aint0++;
+  int_lt_int_else ();
+  int_gt_int_else ();
+  int_gte_int_else ();
+  int_lte_int_else ();
+
+  aint1 = 0x10;
+  int_lt_lit_else ();
+  int_gt_lit_else ();
+  int_lte_lit_else ();
+  int_gte_lit_else ();
+
+  done ();
+}
diff --git a/src/regression/compare3.c b/src/regression/compare3.c
new file mode 100644
index 0000000..480eceb
--- /dev/null
+++ b/src/regression/compare3.c
@@ -0,0 +1,247 @@
+#include "gpsim_assert.h"
+//
+// compare3.c
+// regression testing program for comparing literals to variables
+//
+
+
+unsigned char failures = 0;
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+// compare to 0
+// assumes
+// achar0 == 0
+// achar1 != 0
+// aint0  == 0
+// aint1  != 0
+
+void c_0(void)
+{
+
+  if(achar0 != 0)
+    failures++;
+
+  if(achar0)
+    failures++;
+
+  if(achar1 == 0)
+    failures++;
+
+  if(!achar1)
+    failures++;
+
+  if(aint0 != 0)
+    failures++;
+
+  if(aint0)
+    failures++;
+
+  if(aint1 == 0)
+    failures++;
+
+  if(!aint1)
+    failures++;
+
+}
+
+// compare to 1
+// assumes
+// achar0 != 1
+// achar1 == 1
+// aint0  != 1
+// aint1  == 1
+
+void c_1(void)
+{
+
+  if(achar0 == 1)
+    failures++;
+
+  if(achar1 != 1)
+    failures++;
+
+  if(aint0 == 1)
+    failures++;
+
+  if(aint1 != 1)
+    failures++;
+
+}
+
+// compare to 2
+// assumes
+// achar0 == 2
+// aint0  == 2
+
+void c_2(void)
+{
+
+  if(achar0 != 2)
+    failures++;
+
+  if(aint0 != 2)
+    failures++;
+
+}
+
+// compare to 0xff
+// assumes
+// achar0 == 0xff
+// aint0  == 0xff
+
+void c_ff(void)
+{
+
+  if(achar0 != 0xff)
+    failures++;
+
+  if(aint0 != 0xff)
+    failures++;
+
+  if(aint0 == 0xfe)
+    failures++;
+
+  if(aint0 == 0xff00)
+    failures++;
+
+}
+
+
+// compare to 0x00a5
+// assumes
+// achar0  == 0xa5
+// aint0  == 0x00a5
+
+void c_a5(void)
+{
+
+  if(achar0 != 0xa5)
+    failures++;
+
+  if(aint0 != 0xa5)
+    failures++;
+
+  if(aint0 == 0xa4)
+    failures++;
+
+  if(aint0 == 0xa500)
+    failures++;
+
+}
+
+// compare to 0xa500
+// assumes
+// achar0  == 0xa5
+// aint0  == 0xa500
+
+void c_a500(void)
+{
+
+  if(achar0 == 0xa500)
+    failures++;
+
+  if(aint0 != 0xa500)
+    failures++;
+
+  if(aint0 == 0xa400)
+    failures++;
+
+  if(aint0 == 0x00a5)
+    failures++;
+
+}
+
+// compare to 0xabcd
+// assumes
+// achar0  == 0xa5
+// aint0  == 0xabcd
+
+void c_abcd(void)
+{
+
+  if(achar0 == 0xabcd)
+    failures++;
+
+  if(aint0 != 0xabcd)
+    failures++;
+
+  if(aint0 == 0xab00)
+    failures++;
+
+  if(aint0 == 0x00cd)
+    failures++;
+
+  if(aint0 == 0x05cd)
+    failures++;
+
+  if(aint0 == 0xab05)
+    failures++;
+
+  if(aint0 == 0xab01)
+    failures++;
+
+  if(aint0 == 0x01cd)
+    failures++;
+
+  //  if(aint0 == 0x1234abcd)
+    //    failures++;
+
+}
+
+// assumes achar1 == 0
+void c_ifelse1(void)
+{
+
+  if(achar0)
+    achar0 = achar1;
+  else
+    achar0 = 0;
+
+  if(achar0)
+    failures++;
+}
+
+void
+main (void)
+{
+
+  aint1 = 1;
+  achar1 = 1;
+  c_0();
+  c_1();
+
+  aint0 = 2;
+  achar0 = 2;
+  c_2();
+
+  aint0 = 0xff;
+  achar0 = 0xff;
+  c_ff();
+
+  aint0 = 0xa5;
+  achar0 = 0xa5;
+  c_a5();
+
+  aint0 = 0xabcd;
+  c_abcd();
+
+  achar0 = 0;
+  achar1 = 0;
+  c_ifelse1();
+
+  achar0 = 1;
+  c_ifelse1();
+
+  done ();
+}
diff --git a/src/regression/compare4.c b/src/regression/compare4.c
new file mode 100644
index 0000000..98c22ca
--- /dev/null
+++ b/src/regression/compare4.c
@@ -0,0 +1,317 @@
+#include "gpsim_assert.h"
+//
+// compare4.c
+// regression testing program for comparing signed chars and ints
+//
+
+//#define  COMPARE_OUT_OF_RANGE 1
+
+unsigned char failures = 0;
+
+int int0 = 0;
+int int1 = 0;
+char char0 = 0;
+char char1 = 0;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+// compare to 0
+// assumes
+// char0 == 0
+// char1 != 0
+// int0  == 0
+// int1  != 0
+
+void c_0(void)
+{
+
+  if(char0 != 0)
+    failures++;
+
+  if(char0)
+    failures++;
+
+  if(char1 == 0)
+    failures++;
+
+  if(!char1)
+    failures++;
+
+  if(int0 != 0)
+    failures++;
+
+  if(int0)
+    failures++;
+
+  if(int1 == 0)
+    failures++;
+
+  if(!int1)
+    failures++;
+
+  if(char0>0)
+    failures++;
+
+  if(int0>0)
+    failures++;
+
+  if(char0<0)
+    failures++;
+
+  if(int0<0)
+    failures++;
+
+}
+
+// compare to 1
+// assumes
+// char0 != 1
+// char1 == 1
+// int0  != 1
+// int1  == 1
+
+void c_1(void)
+{
+
+  if(char0 == 1)
+    failures++;
+
+  if(char1 != 1)
+    failures++;
+
+  if(int0 == 1)
+    failures++;
+
+  if(int1 != 1)
+    failures++;
+
+  if(char0 < 0)
+    failures++;
+
+  if(int0 < 0)
+    failures++;
+
+}
+
+// compare to 2
+// assumes
+// achar0 == 2
+// aint0  == 2
+
+void c_2(void)
+{
+
+  if(char0 != 2)
+    failures++;
+
+  if(int0 != 2)
+    failures++;
+
+}
+
+// compare to 0xff
+// assumes
+// achar0 == 0xff
+// aint0  == 0xff
+
+void c_ff(void)
+{
+
+  if(char0 != (char)0xff)
+    failures++;
+
+  if(int0 != 0xff)
+    failures++;
+
+  if(int0 == 0xfe)
+    failures++;
+
+  if(int0 == 0xff00)
+    failures++;
+
+}
+
+
+// compare to 0x00a5
+// assumes
+// char0  == 0xa5
+// int0  == 0x00a5
+
+void c_a5(void)
+{
+
+  if(char0 != (char)0xa5)
+    failures++;
+
+  if(int0 != 0xa5)
+    failures++;
+
+  if(int0 == 0xa4)
+    failures++;
+
+  if(int0 == 0xa500)
+    failures++;
+
+}
+
+// compare to 0xa500
+// assumes
+// char0  == 0xa5
+// int0  == 0xa500
+
+void c_a500(void)
+{
+
+#ifdef COMPARE_OUT_OF_RANGE
+  if(char0 == 0xa500)
+    failures++;
+#endif
+
+  if(int0 != 0xa500)
+    failures++;
+
+  if(int0 != 0x44)
+    int0 = 0x28;
+
+  if(int0 == 0xa400)
+    failures++;
+
+  if(int0 == 0x00a5)
+    failures++;
+
+}
+
+// compare to 0xabcd
+// assumes
+// char0  == 0xa5
+// int0  == 0xabcd
+
+void c_abcd(void)
+{
+#ifdef COMPARE_OUT_OF_RANGE
+  if(char0 == 0xabcd)
+    failures++;
+#endif
+/*
+  if(int0 != 0xabcd)
+    failures++;
+*/
+  if(int0 == 0xab00)
+    failures++;
+
+  if(int0 == 0x00cd)
+    failures++;
+
+  if(int0 == 0x05cd)
+    failures++;
+
+  if(int0 == 0xab05)
+    failures++;
+
+  if(int0 == 0xab01)
+    failures++;
+
+  if(int0 == 0x01cd)
+    failures++;
+
+  if(int0 > 0)
+    failures++;
+
+#ifdef COMPARE_OUT_OF_RANGE
+  if(int0 == 0x1234abcd)
+    failures++;
+#endif
+
+}
+
+// assumes char1 == 0
+void c_ifelse1(void)
+{
+
+  if(char0)
+    char0 = char1;
+  else
+    char0 = 0;
+
+  if(char0)
+    failures++;
+}
+
+// assumes char0 = -1
+// assumes int0 = -1
+
+void c_minus1(void)
+{
+  if(char0 != -1)
+    failures++;
+
+  if(int0 != -1)
+    failures++;
+
+  if(char0 != int0)
+    failures++;
+
+  if(char0>0)
+    failures++;
+
+  if(int0>0)
+    failures++;
+}
+
+void c_c0gtc1(void)
+{
+
+  if(char0 < char1)
+    failures++;
+}
+
+void
+main (void)
+{
+
+  int1 = 1;
+  char1 = 1;
+  c_0();
+  c_1();
+
+  int0 = 2;
+  char0 = 2;
+  c_2();
+
+  int0 = 0xff;
+  char0 = 0xff;
+  c_ff();
+
+  int0 = 0xa5;
+  char0 = 0xa5;
+  c_a5();
+
+  int0 = 0xabcd;
+  //c_abcd();
+
+  char0 = 0;
+  char1 = 0;
+  c_ifelse1();
+
+  char0 = 1;
+  c_ifelse1();
+
+  char0 = -1;
+  int0 = -1;
+  c_minus1();
+
+
+  char0 = 5;
+  char1 = 3;
+  c_c0gtc1();
+
+  char1 = -3;
+  c_c0gtc1();
+
+  done ();
+}
diff --git a/src/regression/compare5.c b/src/regression/compare5.c
new file mode 100644
index 0000000..238755a
--- /dev/null
+++ b/src/regression/compare5.c
@@ -0,0 +1,429 @@
+#include "gpsim_assert.h"
+//
+// compare5.c
+// regression testing program for comparing longs
+//
+
+#define  COMPARE_OUT_OF_RANGE 1
+
+unsigned char failures = 0;
+
+int int0 = 0;
+int int1 = 0;
+char char0 = 0;
+char char1 = 0;
+long long0 = 0;
+long long1 = 0;
+unsigned long ulong0 = 0;
+unsigned long ulong1 = 0;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+// compare to 0
+// assumes
+// long0 == 0
+// ulong0 == 0
+
+void c_0(void)
+{
+
+  if(long0 != 0)
+    failures++;
+
+  if(long0 > 0)
+    failures++;
+
+  if(ulong0 != 0)
+    failures++;
+
+  if(ulong0 > 0)
+    failures++;
+
+}
+
+// compare to 1
+// assumes
+// long1 == 1
+// ulong1 == 1
+
+void c_1(void)
+{
+
+  if(long0 == 1)
+    failures++;
+
+  if(long1 != 1)
+    failures++;
+
+  if(ulong0 == 1)
+    failures++;
+
+  if(ulong1 != 1)
+    failures++;
+
+  if(long1 < 0)
+    failures++;
+
+  if(long1 < 1)
+    failures++;
+
+  if(ulong1 < 1)
+    failures++;
+
+  if(long1 > 1)
+    failures++;
+
+  if(ulong1 > 1)
+    failures++;
+}
+
+// compare to 2
+// assumes
+// long0 == 2
+// ulong0  == 2
+
+void c_2(void)
+{
+
+  if(long0 != 2)
+    failures++;
+
+  if(ulong0 != 2)
+    failures++;
+
+  if(long1 == 2)
+    failures++;
+
+  if(ulong1 == 2)
+    failures++;
+
+}
+
+// compare to 0xff
+// assumes
+// achar0 == 0xff
+// aint0  == 0xff
+
+void c_ff(void)
+{
+
+  if(long0 != 0xff)
+    failures++;
+
+  if(ulong0 != 0xff)
+    failures++;
+
+  if(long1 == 0xff)
+    failures++;
+
+  if(ulong1 == 0xff)
+    failures++;
+
+
+}
+
+// compare to 0x200
+// assumes
+// achar0 == 0x200
+// aint0  == 0x200
+
+void c_200(void)
+{
+
+  if(long0 != 0x200)
+    failures++;
+
+  if(ulong0 != 0x200)
+    failures++;
+
+  if(long1 == 0x200)
+    failures++;
+
+  if(ulong1 == 0x200)
+    failures++;
+
+
+}
+
+// compare to 0x20000
+// assumes
+// long0  == 0x20000
+// ulong0 == 0x20000
+// long1  != 0x20000
+// ulong1 != 0x20000
+
+void c_20000(void)
+{
+
+  if(long0 != 0x20000)
+    failures++;
+
+  if(ulong0 != 0x20000)
+    failures++;
+
+  if(long1 == 0x20000)
+    failures++;
+
+  if(ulong1 == 0x20000)
+    failures++;
+
+  if(long0 <= 0x10000)
+    failures++;
+
+  if(long0 < 0x10000)
+    failures++;
+
+/*  if(long0 < 0x12345)
+    failures++;
+*/
+  if(long0 == 0)
+    failures++;
+}
+
+// compare to 0x00a5
+// assumes
+// char0  == 0xa5
+// int0  == 0x00a5
+
+void c_a5(void)
+{
+
+  if(char0 != 0xa5)
+    failures++;
+
+  if(int0 != 0xa5)
+    failures++;
+
+  if(int0 == 0xa4)
+    failures++;
+
+  if(int0 == 0xa500)
+    failures++;
+
+}
+
+// compare to 0xa500
+// assumes
+// char0  == 0xa5
+// int0  == 0xa500
+
+void c_a500(void)
+{
+
+#ifdef COMPARE_OUT_OF_RANGE
+  if(char0 == 0xa500)
+    failures++;
+#endif
+
+  if(int0 != 0xa500)
+    failures++;
+
+  if(int0 == 0xa400)
+    failures++;
+
+  if(int0 == 0x00a5)
+    failures++;
+
+}
+
+// compare to 0xabcd
+// assumes
+// char0  == 0xa5
+// int0  == 0xabcd
+
+void c_abcd(void)
+{
+#ifdef COMPARE_OUT_OF_RANGE
+  if(char0 == 0xabcd)
+    failures++;
+#endif
+
+  if(int0 != 0xabcd)
+    failures++;
+
+  if(int0 == 0xab00)
+    failures++;
+
+  if(int0 == 0x00cd)
+    failures++;
+
+  if(int0 == 0x05cd)
+    failures++;
+
+  if(int0 == 0xab05)
+    failures++;
+
+  if(int0 == 0xab01)
+    failures++;
+
+  if(int0 == 0x01cd)
+    failures++;
+
+  if(int0 > 0)
+    failures++;
+
+#ifdef COMPARE_OUT_OF_RANGE
+  if(int0 == 0x1234abcd)
+    failures++;
+#endif
+
+}
+
+// assumes char1 == 0
+void c_ifelse1(void)
+{
+
+  if(char0)
+    char0 = char1;
+  else
+    char0 = 0;
+
+  if(char0)
+    failures++;
+}
+
+// assumes char0 = -1
+// assumes int0 = -1
+
+void c_minus1(void)
+{
+  if(long0 != -1)
+    failures++;
+
+  if(long0 > 0)
+    failures++;
+
+  if(long1 < 0)
+    failures++;
+/*
+  if(long1 < 2)
+    failures++;
+*/
+}
+
+// assumes
+// long0 = long1 = ulong0 = ulong1 == 0
+
+void c_long2long_eq(void)
+{
+
+  if(long0 != long1)
+    failures++;
+
+  if(ulong0 != ulong1)
+    failures++;
+
+  if(long0 != ulong1)
+    failures++;
+
+  if(long0 > long1)
+    failures++;
+
+  if(long0 < long1)
+    failures++;
+
+  if(long0 > ulong0)
+    failures++;
+
+  if(long0 < ulong0)
+    failures++;
+}
+
+// assumes
+// long0 = ulong0 == 0
+// long1 = ulong1 == 1
+
+void c_long2long_neq(void)
+{
+
+  if(long0 == long1)
+    failures++;
+
+  if(ulong0 == ulong1)
+    failures++;
+
+  if(long1 != ulong1)
+    failures++;
+
+  if(long1 < long0)
+    failures++;
+
+  if(long1 <= long0)
+    failures++;
+
+  if(ulong1 < ulong0)
+    failures++;
+
+  if(ulong1 <= ulong0)
+    failures++;
+
+}
+
+
+//  long0=-100;
+//  long1=-1000;
+void
+c_long2neglit(void)
+{
+
+  if(long0>0)
+    failures++;
+  if(long1>0)
+    failures++;
+
+  if(long1 > long0)
+    failures++;
+
+  if(long1 > 100)
+    failures++;
+
+  if(long0 > -50)
+    failures++;
+
+  if(long1 < -5000)
+    failures++;
+}
+
+void
+main (void)
+{
+
+  c_0();
+
+  c_long2long_eq();
+
+  long1 = 1;
+  ulong1 = 1;
+  c_1();
+  c_long2long_neq();
+
+  long0 = 2;
+  ulong0 = 2;
+  c_2();
+
+  long0 = 0xff;
+  ulong0 = 0xff;
+  c_ff();
+
+  long0 = 0x200;
+  ulong0 = 0x200;
+  c_200();
+
+  long0 = 0x20000;
+  ulong0 = 0x20000;
+  c_20000();
+
+  long0 = -1;
+  c_minus1();
+
+  long0=-100;
+  long1=-1000;
+  c_long2neglit();
+
+  done ();
+}
diff --git a/src/regression/compare6.c b/src/regression/compare6.c
new file mode 100644
index 0000000..f189ba8
--- /dev/null
+++ b/src/regression/compare6.c
@@ -0,0 +1,184 @@
+#include "gpsim_assert.h"
+// Compound comparisons
+
+unsigned char success = 0;
+unsigned char failures = 0;
+unsigned char dummy = 0;
+
+//bit bit0 = 0;
+int int0 = 0;
+int int1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+char char0 = 0;
+char char1 = 0;
+char long0 = 0;
+char long1 = 0;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void
+c_char(void)
+{
+
+  if(char0 || char1)
+    failures++;
+
+  if(char0 && char1)
+    failures++;
+
+  if(char0 > char1)
+    failures++;
+
+  if((char0+1)  < char1)
+    failures++;
+
+  if((char0+5) >= (char1+9))
+    failures++;
+
+  char0++;
+
+  if(char0 && char1)
+    failures++;
+
+  if(char0 != (char1+1) )
+    failures++;
+
+  if(!char0)
+    failures++;
+
+  if(char1 || !char0)
+    failures++;
+
+  if((char0 >5 ) && (char0 < 10)) 
+    failures++;
+
+  char0 +=5; /* char0 = 6 now */
+
+
+  if(!((char0 >5 ) && (char0 < 10)))
+    failures++;
+
+}
+
+
+void
+c_int(void)
+{
+
+  if(int0 || int1)
+    failures++;
+
+  if(int0 && int1)
+    failures++;
+
+  if(int0 > int1)
+    failures++;
+
+  if((int0+1)  < int1)
+    failures++;
+
+  if((int0+5) >= (int1+9))
+    failures++;
+
+  int0++;
+
+  if(int0 && int1)
+    failures++;
+
+  if(int0 != (int1+1) )
+    failures++;
+
+  if(!int0)
+    failures++;
+
+  if(int1 || !int0)
+    failures++;
+
+  if((int0 >5 ) && (int0 < 10)) 
+    failures++;
+
+  int0 +=5; /* int0 = 6 now */
+
+
+  if(!((int0 >5 ) && (int0 < 10)))
+    failures++;
+
+}
+
+
+void
+c_long(void)
+{
+
+  if(long0 || long1)
+    failures++;
+
+  if(long0 && long1)
+    failures++;
+
+  if(long0 > long1)
+    failures++;
+
+  if((long0+1)  < long1)
+    failures++;
+
+  if((long0+5) >= (long1+9))
+    failures++;
+
+  long0++;
+
+  if(long0 && long1)
+    failures++;
+
+  if(long0 != (long1+1) )
+    failures++;
+
+  if(!long0)
+    failures++;
+
+  if(long1 || !long0)
+    failures++;
+
+  if((long0 >5 ) && (long0 < 10)) 
+    failures++;
+
+  long0 +=5; /* long0 = 6 now */
+
+
+  if(!((long0 >5 ) && (long0 < 10)))
+    failures++;
+
+}
+
+void
+c_uminus(void)
+{
+
+  int1 = -int0;
+  if(int1 < 0)
+    failures++;
+}
+
+void
+main (void)
+{
+
+  c_char();
+  c_int();
+  c_long();
+
+  int0 = -1;
+  c_uminus();
+  if(int1 != 1)
+    failures++;
+
+  success = failures;
+  done ();
+}
+
diff --git a/src/regression/compare7.c b/src/regression/compare7.c
new file mode 100644
index 0000000..1c025c6
--- /dev/null
+++ b/src/regression/compare7.c
@@ -0,0 +1,311 @@
+#include "gpsim_assert.h"
+#include "picregs.h"
+// Signed comparisons of the form:  (variable<LIT)
+//
+// This regression test exercises all of the boundary
+// conditions in literal less than comparisons. There
+// are numerous opportunities to optimize these comparison
+// and each one has an astonishing capability of failing
+// a boundary condition.
+
+unsigned char failures = 0;
+unsigned char result = 0;
+
+//bit bit0 = 0;
+int int0 = 0;
+int int1 = 0;
+signed char char0 = 0;
+signed char char1 = 0;
+char long0 = 0;
+char long1 = 0;
+
+
+/* *** NOTE ***  This particular test takes quite a while to run 
+ * ~ 10,000,000 instruction cycles. (2.5 seconds on a 20Mhz PIC).
+ * The WDT will reset the CPU if it's enabled. So disable it...
+*/
+
+typedef unsigned int word;
+
+//word at 0x2007  CONFIG = wdt_off & pwrte_on;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void c_char_lt_lit1(unsigned char expected_result)
+{
+  result = 0;
+
+  if(char0 < -0x7f)
+    result |= 1;
+
+
+  if(char0 < -1)
+    result |= 2;
+
+  if(char0 < 0)
+    result |= 4;
+
+  if(char0 < 1)
+    result |= 8;
+
+  if(char0 < 0x7f)
+    result |= 0x10;
+  
+  if(result != expected_result)
+    failures++;
+}
+
+
+void char_compare(void)
+{
+  char0 = 0x7f;
+  c_char_lt_lit1(0);
+
+  char0 = 0x7e;
+  c_char_lt_lit1(0x10);
+
+  char0 = 0x40;
+  c_char_lt_lit1(0x10);
+
+  char0 = 0x2;
+  c_char_lt_lit1(0x10);
+
+  char0 = 0x1;
+  c_char_lt_lit1(0x10);
+
+  char0 = 0;
+  c_char_lt_lit1(0x18);
+
+  char0 = -1;
+  c_char_lt_lit1(0x1c);
+
+  char0 = -2;
+  c_char_lt_lit1(0x1e);
+
+  char0 = -0x40;
+  c_char_lt_lit1(0x1e);
+
+  char0 = -0x7e;
+  c_char_lt_lit1(0x1e);
+
+  char0 = -0x7f;
+  c_char_lt_lit1(0x1e);
+
+  char0 = 0x80;
+  c_char_lt_lit1(0x1f);
+
+
+  /* Now test entire range */
+
+  for(char0=1; char0 != 0x7f; char0++)
+    c_char_lt_lit1(0x10);
+
+
+  for(char0=-0x7f; char0 != -1; char0++)
+    c_char_lt_lit1(0x1e);
+
+
+}
+
+void c_int_lt_lit1(unsigned char expected_result)
+{
+  result = 0;
+
+  if(int0 < 0)
+    result |= 1;
+
+  if(int0 < 1)
+    result |= 2;
+
+
+  if(int0 < 0xff)
+    result |= 4;
+
+  if(int0 < 0x100)
+    result |= 8;
+
+  if(int0 < 0x0101)
+    result |= 0x10;
+  
+  if(int0 < 0x01ff)
+    result |= 0x20;
+  
+  if(int0 < 0x0200)
+    result |= 0x40;
+
+  if(int0 < 0x0201)
+    result |= 0x80;
+
+  if(result != expected_result)
+    failures=1;
+
+}
+
+
+void int_compare1(void)
+{
+  int0 = -1;
+  c_int_lt_lit1(0xff);
+
+  int0 = 0;
+  c_int_lt_lit1(0xfe);
+
+  int0 = 1;
+  c_int_lt_lit1(0xfc);
+
+  int0 = 2;
+  c_int_lt_lit1(0xfc);
+
+  int0 = 0xfe;
+  c_int_lt_lit1(0xfc);
+
+  int0 = 0xff;
+  c_int_lt_lit1(0xf8);
+
+  int0 = 0x100;
+  c_int_lt_lit1(0xf0);
+
+  int0 = 0x101;
+  c_int_lt_lit1(0xe0);
+
+  int0 = 0x1fe;
+  c_int_lt_lit1(0xe0);
+
+  int0 = 0x1ff;
+  c_int_lt_lit1(0xc0);
+
+  int0 = 0x200;
+  c_int_lt_lit1(0x80);
+
+  int0 = 0x201;
+  c_int_lt_lit1(0x0);
+
+  int0 = 0x7f00;
+  c_int_lt_lit1(0x0);
+
+  /* now check contiguous ranges */
+
+  for(int0 = -0x7fff; int0 != -1; int0++)
+    c_int_lt_lit1(0xff);
+
+  for(int0 = 1; int0 != 0xff; int0++)
+    c_int_lt_lit1(0xfc);
+
+  for(int0 = 0x201; int0 != 0x7fff; int0++)
+    c_int_lt_lit1(0);
+
+}
+
+
+
+void c_int_lt_lit2(unsigned char expected_result)
+{
+  result = 0;
+
+  if(int0 < -0x7fff)
+    result |= 1;
+
+  if(int0 < -0x7f00)
+    result |= 2;
+
+  if(int0 < -0x7eff)
+    result |= 4;
+
+  if(int0 < -0x7e00)
+    result |= 8;
+
+  if(int0 < -0x0101)
+    result |= 0x10;
+  
+  if(int0 < -0x0100)
+    result |= 0x20;
+  
+  if(int0 < -0xff)
+    result |= 0x40;
+
+  if(int0 < -1)
+    result |= 0x80;
+
+  if(result != expected_result)
+    failures=1;
+}
+
+void int_compare2(void)
+{
+  int0 = -0x7fff;
+  c_int_lt_lit2(0xfe);
+
+  int0 = -0x7f00;
+  c_int_lt_lit2(0xfc);
+
+  int0 = -0x7eff;
+  c_int_lt_lit2(0xf8);
+
+  int0 = -0x7e00;
+  c_int_lt_lit2(0xf0);
+
+  int0 = -0x4567;
+  c_int_lt_lit2(0xf0);
+
+  int0 = -0x200;
+  c_int_lt_lit2(0xf0);
+
+  int0 = -0x102;
+  c_int_lt_lit2(0xf0);
+
+  int0 = -0x101;
+  c_int_lt_lit2(0xe0);
+
+  int0 = -0x100;
+  c_int_lt_lit2(0xc0);
+
+  int0 = -0xff;
+  c_int_lt_lit2(0x80);
+
+  int0 = -0x02;
+  c_int_lt_lit2(0x80);
+
+  int0 = -0x01;
+  c_int_lt_lit2(0x00);
+
+  int0 = 0;
+  c_int_lt_lit2(0x00);
+
+  int0 = 1;
+  c_int_lt_lit2(0x00);
+
+  int0 = 0x7fff;
+  c_int_lt_lit2(0x00);
+
+  /* now check contiguous ranges */
+  int0 = -0x7f01;
+  c_int_lt_lit2(0xfe);
+
+  for(int0 = -0x7ffe; int0 != -0x7f01; int0++)
+    c_int_lt_lit2(0xfe);
+
+  for(int0 = -0x7e00; int0 != -0x101; int0++)
+    c_int_lt_lit2(0xf0);
+
+  for(int0 = -1; int0 != 0x7fff; int0++)
+    c_int_lt_lit2(0);
+}
+
+
+void
+main (void)
+{
+  char_compare();
+  __asm clrwdt __endasm;
+  int_compare1();
+  __asm clrwdt __endasm;
+  int_compare2();
+  __asm clrwdt __endasm;
+
+  done ();
+}
diff --git a/src/regression/compare8.c b/src/regression/compare8.c
new file mode 100644
index 0000000..19da23a
--- /dev/null
+++ b/src/regression/compare8.c
@@ -0,0 +1,322 @@
+#include "gpsim_assert.h"
+#include "picregs.h"
+// Signed comparisons of the form:  (variable>LIT)
+//
+// This regression test exercises all of the boundary
+// conditions in literal less than comparisons. There
+// are numerous opportunities to optimize these comparison
+// and each one has an astonishing capability of failing
+// a boundary condition.
+
+unsigned char failures = 0;
+unsigned char result = 0;
+
+//bit bit0 = 0;
+int int0 = 0;
+int int1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+signed char char0 = 0;
+signed char char1 = 0;
+char long0 = 0;
+char long1 = 0;
+
+/* *** NOTE ***  This particular test takes quite a while to run 
+ * ~ 10,000,000 instruction cycles. (2.5 seconds on a 20Mhz PIC).
+ * The WDT will reset the CPU if it's enabled. So disable it...
+*/
+
+typedef unsigned int word;
+
+//word at 0x2007  CONFIG = wdt_off & pwrte_on;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void c_char_gt_lit1(unsigned char expected_result)
+{
+  result = 0;
+
+  if(char0 > -0x7f)
+    result |= 1;
+
+
+  if(char0 > -1)
+    result |= 2;
+
+  if(char0 > 0)
+    result |= 4;
+
+  if(char0 > 1)
+    result |= 8;
+
+  if(char0 > 0x7e)
+    result |= 0x10;
+  
+  if(char0 > 0x7f)
+    result |= 0x20;
+  
+  if(result != expected_result)
+    failures++;
+}
+
+
+void char_compare(void)
+{
+  char0 = 0x7f;
+  c_char_gt_lit1(0x1f);
+
+  char0 = 0x7e;
+  c_char_gt_lit1(0x0f);
+
+  char0 = 0x40;
+  c_char_gt_lit1(0x0f);
+
+  char0 = 0x2;
+  c_char_gt_lit1(0x0f);
+
+  char0 = 0x1;
+  c_char_gt_lit1(0x07);
+
+  char0 = 0;
+  c_char_gt_lit1(0x03);
+
+  char0 = -1;
+  c_char_gt_lit1(0x01);
+
+  char0 = -2;
+  c_char_gt_lit1(0x01);
+
+  char0 = -0x40;
+  c_char_gt_lit1(0x01);
+
+  char0 = -0x7e;
+  c_char_gt_lit1(0x01);
+
+  char0 = -0x7f;
+  c_char_gt_lit1(0x00);
+
+  char0 = 0x80;
+  c_char_gt_lit1(0x00);
+
+
+  /* Now test entire range */
+
+  for(char0=2; char0 != 0x7f; char0++)
+    c_char_gt_lit1(0x0f);
+
+
+  for(char0=-0x7e; char0 != -1; char0++)
+    c_char_gt_lit1(0x01);
+
+
+}
+
+
+void c_int_gt_lit1(unsigned char expected_result)
+{
+  result = 0;
+
+  if(int0 > 0)
+    result |= 1;
+
+  if(int0 > 1)
+    result |= 2;
+
+
+  if(int0 > 0xff)
+    result |= 4;
+
+  if(int0 > 0x100)
+    result |= 8;
+
+  if(int0 > 0x0101)
+    result |= 0x10;
+  
+  if(int0 > 0x01ff)
+    result |= 0x20;
+  
+  if(int0 > 0x0200)
+    result |= 0x40;
+
+  if(int0 > 0x0201)
+    result |= 0x80;
+
+  if(result != expected_result)
+    failures=1;
+
+}
+
+
+void int_compare1(void)
+{
+  int0 = -1;
+  c_int_gt_lit1(0x00);
+
+  int0 = 0;
+  c_int_gt_lit1(0x00);
+
+  int0 = 1;
+  c_int_gt_lit1(0x01);
+
+  int0 = 2;
+  c_int_gt_lit1(0x03);
+
+  int0 = 0xfe;
+  c_int_gt_lit1(0x03);
+
+  int0 = 0xff;
+  c_int_gt_lit1(0x03);
+
+  int0 = 0x100;
+  c_int_gt_lit1(0x07);
+
+  int0 = 0x101;
+  c_int_gt_lit1(0x0f);
+
+  int0 = 0x102;
+  c_int_gt_lit1(0x1f);
+
+  int0 = 0x1fe;
+  c_int_gt_lit1(0x1f);
+
+  int0 = 0x1ff;
+  c_int_gt_lit1(0x1f);
+
+  int0 = 0x200;
+  c_int_gt_lit1(0x3f);
+
+  int0 = 0x201;
+  c_int_gt_lit1(0x7f);
+
+  int0 = 0x7f00;
+  c_int_gt_lit1(0xff);
+
+  /* now check contiguous ranges */
+
+  for(int0 = -0x7fff; int0 != -1; int0++)
+    c_int_gt_lit1(0x00);
+
+  for(int0 = 2; int0 != 0xff; int0++)
+    c_int_gt_lit1(0x03);
+
+  for(int0 = 0x202; int0 != 0x7fff; int0++)
+    c_int_gt_lit1(0xff);
+
+}
+
+
+void c_int_gt_lit2(unsigned char expected_result)
+{
+  result = 0;
+
+  if(int0 > -0x7fff)
+    result |= 1;
+
+  if(int0 > -0x7f00)
+    result |= 2;
+
+  if(int0 > -0x7eff)
+    result |= 4;
+
+  if(int0 > -0x7e00)
+    result |= 8;
+
+  if(int0 > -0x0101)
+    result |= 0x10;
+  
+  if(int0 > -0x0100)
+    result |= 0x20;
+  
+  if(int0 > -0xff)
+    result |= 0x40;
+
+  if(int0 > -1)
+    result |= 0x80;
+
+  if(result != expected_result)
+    failures=1;
+}
+
+void int_compare2(void)
+{
+  int0 = -0x7fff;
+  c_int_gt_lit2(0x00);
+
+  int0 = -0x7f00;
+  c_int_gt_lit2(0x01);
+
+  int0 = -0x7eff;
+  c_int_gt_lit2(0x03);
+
+  int0 = -0x7e00;
+  c_int_gt_lit2(0x07);
+
+  int0 = -0x7dff;
+  c_int_gt_lit2(0x0f);
+
+  int0 = -0x4567;
+  c_int_gt_lit2(0x0f);
+
+  int0 = -0x200;
+  c_int_gt_lit2(0x0f);
+
+  int0 = -0x102;
+  c_int_gt_lit2(0x0f);
+
+  int0 = -0x101;
+  c_int_gt_lit2(0x0f);
+
+  int0 = -0x100;
+  c_int_gt_lit2(0x1f);
+
+  int0 = -0xff;
+  c_int_gt_lit2(0x3f);
+
+  int0 = -0x02;
+  c_int_gt_lit2(0x7f);
+
+  int0 = -0x01;
+  c_int_gt_lit2(0x7f);
+
+  int0 = 0;
+  c_int_gt_lit2(0xff);
+
+  int0 = 1;
+  c_int_gt_lit2(0xff);
+
+  int0 = 0x7fff;
+  c_int_gt_lit2(0xff);
+
+  /* now check contiguous ranges */
+
+  for(int0 = -0x7ffe; int0 != -0x7f01; int0++)
+    c_int_gt_lit2(0x01);
+
+  for(int0 = -0x7dff; int0 != -0x101; int0++)
+    c_int_gt_lit2(0x0f);
+
+  for(int0 = 0; int0 != 0x7fff; int0++)
+    c_int_gt_lit2(0xff);
+
+}
+
+
+
+
+void
+main (void)
+{
+  char_compare();
+  __asm clrwdt __endasm;
+  int_compare1();
+  __asm clrwdt __endasm;
+  int_compare2();
+  __asm clrwdt __endasm;
+
+  done ();
+}
diff --git a/src/regression/compare9.c b/src/regression/compare9.c
new file mode 100644
index 0000000..d8caad0
--- /dev/null
+++ b/src/regression/compare9.c
@@ -0,0 +1,305 @@
+#include "gpsim_assert.h"
+#include "picregs.h"
+// Signed comparisons of the form:  (variable<=LIT)
+//
+// This regression test exercises all of the boundary
+// conditions in literal less than or equal comparisons. There
+// are numerous opportunities to optimize these comparison
+// and each one has an astonishing capability of failing
+// a boundary condition.
+
+unsigned char failures = 0;
+unsigned char result = 0;
+
+int int0 = 0;
+int int1 = 0;
+signed char char0 = 0;
+signed char char1 = 0;
+
+/* *** NOTE ***  This particular test takes quite a while to run 
+ * ~ 10,000,000 instruction cycles. (2.5 seconds on a 20Mhz PIC).
+ * The WDT will reset the CPU if it's enabled. So disable it...
+*/
+
+typedef unsigned int word;
+
+//word at 0x2007  CONFIG = wdt_off & pwrte_on;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void c_char_lte_lit1(unsigned char expected_result)
+{
+  result = 0;
+
+  if(char0 <= -0x7f)
+    result |= 1;
+
+  if(char0 <= -1)
+    result |= 2;
+
+  if(char0 <= 0)
+    result |= 4;
+
+  if(char0 <= 1)
+    result |= 8;
+
+  if(char0 <= 0x7f)
+    result |= 0x10;
+  
+  if(result != expected_result)
+    failures++;
+}
+
+
+void char_compare(void)
+{
+  char0 = 0x7f;
+  c_char_lte_lit1(0x10);
+
+  char0 = 0x7e;
+  c_char_lte_lit1(0x10);
+
+  char0 = 0x40;
+  c_char_lte_lit1(0x10);
+
+  char0 = 0x2;
+  c_char_lte_lit1(0x10);
+
+  char0 = 0x1;
+  c_char_lte_lit1(0x18);
+
+  char0 = 0;
+  c_char_lte_lit1(0x1c);
+
+  char0 = -1;
+  c_char_lte_lit1(0x1e);
+
+  char0 = -2;
+  c_char_lte_lit1(0x1e);
+
+  char0 = -0x40;
+  c_char_lte_lit1(0x1e);
+
+  char0 = -0x7e;
+  c_char_lte_lit1(0x1e);
+
+  char0 = -0x7f;
+  c_char_lte_lit1(0x1f);
+
+  char0 = 0x80;
+  //  c_char_lte_lit1(0x1f);
+
+
+  /* Now test entire range */
+
+  for(char0=2; char0 != 0x7f; char0++)
+    c_char_lte_lit1(0x10);
+
+
+  for(char0=-0x7e; char0 != 0; char0++)
+    c_char_lte_lit1(0x1e);
+
+
+}
+
+void c_int_lte_lit1(unsigned char expected_result)
+{
+  result = 0;
+
+  if(int0 <= 0)
+    result |= 1;
+
+  if(int0 <= 1)
+    result |= 2;
+
+
+  if(int0 <= 0xff)
+    result |= 4;
+
+  if(int0 <= 0x100)
+    result |= 8;
+
+  if(int0 <= 0x0101)
+    result |= 0x10;
+  
+  if(int0 <= 0x01ff)
+    result |= 0x20;
+  
+  if(int0 <= 0x0200)
+    result |= 0x40;
+
+  if(int0 <= 0x0201)
+    result |= 0x80;
+
+  if(result != expected_result)
+    failures=1;
+
+}
+
+
+void int_compare1(void)
+{
+  int0 = -1;
+  c_int_lte_lit1(0xff);
+
+  int0 = 0;
+  c_int_lte_lit1(0xff);
+
+  int0 = 1;
+  c_int_lte_lit1(0xfe);
+
+  int0 = 2;
+  c_int_lte_lit1(0xfc);
+
+  int0 = 0xfe;
+  c_int_lte_lit1(0xfc);
+
+  int0 = 0xff;
+  c_int_lte_lit1(0xfc);
+
+  int0 = 0x100;
+  c_int_lte_lit1(0xf8);
+
+  int0 = 0x101;
+  c_int_lte_lit1(0xf0);
+
+  int0 = 0x1fe;
+  c_int_lte_lit1(0xe0);
+
+  int0 = 0x1ff;
+  c_int_lte_lit1(0xe0);
+
+  int0 = 0x200;
+  c_int_lte_lit1(0xc0);
+
+  int0 = 0x201;
+  c_int_lte_lit1(0x80);
+
+  int0 = 0x7f00;
+  c_int_lte_lit1(0x0);
+
+  /* now check contiguous ranges */
+
+  for(int0 = -0x7fff; int0 != 1; int0++)
+    c_int_lte_lit1(0xff);
+
+  for(int0 = 2; int0 != 0xff; int0++)
+    c_int_lte_lit1(0xfc);
+
+  for(int0 = 0x202; int0 != 0x7fff; int0++)
+    c_int_lte_lit1(0);
+
+}
+
+
+
+void c_int_lte_lit2(unsigned char expected_result)
+{
+  result = 0;
+
+  if(int0 <= -0x7fff)
+    result |= 1;
+
+  if(int0 <= -0x7f00)
+    result |= 2;
+
+  if(int0 <= -0x7eff)
+    result |= 4;
+
+  if(int0 <= -0x7e00)
+    result |= 8;
+
+  if(int0 <= -0x0101)
+    result |= 0x10;
+  
+  if(int0 <= -0x0100)
+    result |= 0x20;
+  
+  if(int0 <= -0xff)
+    result |= 0x40;
+
+  if(int0 <= -1)
+    result |= 0x80;
+
+  if(result != expected_result)
+    failures=1;
+}
+
+void int_compare2(void)
+{
+  int0 = -0x7fff;
+  c_int_lte_lit2(0xff);
+
+  int0 = -0x7f00;
+  c_int_lte_lit2(0xfe);
+
+  int0 = -0x7eff;
+  c_int_lte_lit2(0xfc);
+
+  int0 = -0x7e00;
+  c_int_lte_lit2(0xf8);
+
+  int0 = -0x4567;
+  c_int_lte_lit2(0xf0);
+
+  int0 = -0x200;
+  c_int_lte_lit2(0xf0);
+
+  int0 = -0x102;
+  c_int_lte_lit2(0xf0);
+
+  int0 = -0x101;
+  c_int_lte_lit2(0xf0);
+
+  int0 = -0x100;
+  c_int_lte_lit2(0xe0);
+
+  int0 = -0xff;
+  c_int_lte_lit2(0xc0);
+
+  int0 = -0x02;
+  c_int_lte_lit2(0x80);
+
+  int0 = -0x01;
+  c_int_lte_lit2(0x80);
+
+  int0 = 0;
+  c_int_lte_lit2(0x00);
+
+  int0 = 1;
+  c_int_lte_lit2(0x00);
+
+  int0 = 0x7fff;
+  c_int_lte_lit2(0x00);
+
+  /* now check contiguous ranges */
+
+  for(int0 = -0x7ffe; int0 != -0x7f00; int0++)
+    c_int_lte_lit2(0xfe);
+
+  for(int0 = -0x7dff; int0 != -0x101; int0++)
+    c_int_lte_lit2(0xf0);
+
+  for(int0 = 0; int0 != 0x7fff; int0++)
+    c_int_lte_lit2(0);
+
+}
+
+
+void
+main (void)
+{
+  char_compare();
+  __asm clrwdt __endasm;
+  int_compare1();
+  __asm clrwdt __endasm;
+  int_compare2();
+  __asm clrwdt __endasm;
+
+  done ();
+}
diff --git a/src/regression/configword.c b/src/regression/configword.c
new file mode 100644
index 0000000..fb4728a
--- /dev/null
+++ b/src/regression/configword.c
@@ -0,0 +1,33 @@
+#include "gpsim_assert.h"
+#include "picregs.h"
+
+/* configword.c - illustrates how the configuration word can
+ * be assigned */
+
+unsigned char failures=0;
+unsigned char dummy;
+
+#ifdef __pic14
+typedef unsigned int word;
+static word __at(0x2007) _config = _WDT_OFF & _PWRTE_ON;
+#else /* !__pic14 */
+static __code char __at(__CONFIG2L) _conf2l = _PUT_ON_2L;
+static __code char __at(__CONFIG2H) _conf2h = _WDT_OFF_2H;
+#endif /* !__pic14 */
+
+/* TODO -- write a test that puts the PIC to sleep,
+ * and verify that the WDT wakes it up */
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void main(void)
+{
+  dummy = 0;
+
+  done();
+}
diff --git a/src/regression/create_stc b/src/regression/create_stc
new file mode 100755
index 0000000..4e59f4a
--- /dev/null
+++ b/src/regression/create_stc
@@ -0,0 +1,15 @@
+# Create gpsim script file
+# 
+
+USAGE="Usage: `basename $0` COD_FILE GPSIM_SCRIPT"
+
+if [ $# -lt 2 ] ; then
+  echo "$USAGE"
+  exit 1
+fi
+
+
+echo "load $1" > $2
+echo "run" >> $2
+echo "symbol _failures" >> $2
+echo "quit" >> $2
diff --git a/src/regression/empty.c b/src/regression/empty.c
new file mode 100644
index 0000000..fb4fd26
--- /dev/null
+++ b/src/regression/empty.c
@@ -0,0 +1,22 @@
+#include "gpsim_assert.h"
+
+unsigned char failures = 0;
+
+void foo(void) {
+}
+
+void bar(int arg0) {
+    (void)arg0;
+}
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void main(void) {
+    done();
+}
+
diff --git a/src/regression/for.c b/src/regression/for.c
new file mode 100644
index 0000000..9c9314e
--- /dev/null
+++ b/src/regression/for.c
@@ -0,0 +1,108 @@
+#include "gpsim_assert.h"
+
+unsigned char failures=0;
+
+unsigned int uint0 = 0;
+unsigned int uint1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void for1(void)
+{
+  unsigned char i=0;
+
+  for(i=0; i<10; i++)
+    uchar0++;
+
+  if(uchar0 != 10)
+    failures++;
+
+}
+
+void for2(void)
+{
+  unsigned char i=0;
+  unsigned char j;
+
+  for(i=0; i<10; i++)
+    uchar0++;
+
+  j = (volatile)i;
+
+  if(j != 10)
+    failures++;
+
+}
+
+void for3(void)
+{
+  unsigned int i=0;
+  volatile unsigned int j;
+
+  for(i=0; i<10; i++)
+    uint0++;
+
+  j = i;
+  if(j != 10)
+    failures++;
+
+}
+
+void for4(void)
+{
+
+  for(uint0=1; uint0<10; uint0++)
+    uchar0++;
+
+  if(uchar0 != 9)
+    failures++;
+
+}
+
+void for5(void)
+{
+
+  for(uint0=1; uint0<=10; uint0++)
+    uchar0++;
+
+  if(uchar0 != 10)
+    failures++;
+
+}
+
+void inc_uchar0(void)
+{
+  uchar0++;
+}
+
+void for6(void)
+{
+  uchar0 = 0;
+  for(uint0=1; uint0<=10; uint0++)
+    inc_uchar0();
+
+}
+
+void main(void)
+{
+  for1();
+  for2();
+  for3();
+  uchar0 = 0;
+  for4();
+  uchar0 = 0;
+  for5();
+
+  for6();
+  if(uchar0 != 10)
+    failures++;
+
+  done();
+}
diff --git a/src/regression/gpsim_assert.h b/src/regression/gpsim_assert.h
new file mode 100644
index 0000000..8e39858
--- /dev/null
+++ b/src/regression/gpsim_assert.h
@@ -0,0 +1,64 @@
+/*------------------------------------------------------------------------------
+
+  gpsim_assert.h - assertion macros generating gpsim breakpoints
+
+  Copyright (c) 2006 Borut Razem
+
+  This program is free software; you can redistribute it and/or modify it
+  under the terms of the GNU General Public License as published by the
+  Free Software Foundation; either version 2, or (at your option) any
+  later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+  USA.
+
+------------------------------------------------------------------------------*/
+
+
+#ifndef __PIC_ASSERT_H
+#define __PIC_ASSERT_H
+
+#define MANGLE(e) _##e
+#define STRINGIFY(e) #e
+
+#define ASSERT(e) \
+  __asm \
+  nop \
+  __endasm; \
+  __asm \
+  .direct "a", STRINGIFY(e) \
+  __endasm; \
+  __asm \
+  nop \
+  __endasm;
+
+#define PASSED() \
+  __asm \
+  nop \
+  __endasm; \
+  __asm \
+  .direct "a", "\"PASSED\"" \
+  __endasm; \
+  __asm \
+  nop \
+  __endasm;
+
+#define FAILED() \
+  __asm \
+  nop \
+  __endasm; \
+  __asm \
+  .direct "a", "\"===> FAILED\"" \
+  __endasm; \
+  __asm \
+  nop \
+  __endasm;
+
+#endif
diff --git a/src/regression/init0.c b/src/regression/init0.c
new file mode 100644
index 0000000..fc711e4
--- /dev/null
+++ b/src/regression/init0.c
@@ -0,0 +1,45 @@
+#include "gpsim_assert.h"
+
+unsigned failures = 0;
+
+void
+done(void)
+{
+    ASSERT(MANGLE(failures) == 0);
+    PASSED();
+}
+
+typedef void (void_void_f)(void);
+
+void
+foo(void) {
+    failures--;
+}
+
+void
+bar(void) {
+    failures -= 2;
+}
+
+static void_void_f *
+funcs[] = {
+    &foo,
+    &bar,
+    (void *)0
+};
+
+void
+main(void)
+{
+    void_void_f **ptr;
+    failures = 3;
+
+    ptr = &funcs[0];
+    while (*ptr) {
+        (**ptr)();
+        ptr++;
+    } // while
+
+    done();
+}
+
diff --git a/src/regression/inline.c b/src/regression/inline.c
new file mode 100644
index 0000000..bb2cb3b
--- /dev/null
+++ b/src/regression/inline.c
@@ -0,0 +1,58 @@
+#include "gpsim_assert.h"
+#include "picregs.h"
+
+#pragma preproc_asm -
+
+unsigned char failures=0;
+
+unsigned char test_tris=0;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void
+delay_1ms(void)
+{
+  unsigned char cnt1m = 2;
+  unsigned char cnt500u = 249;
+
+  do {
+    do {
+      __asm
+        nop
+        nop
+      __endasm;
+    } while (--cnt500u > 0);
+  } while (--cnt1m > 0);
+}
+
+
+void main(void)
+{
+  TRISA = 0x0f;
+
+#if defined(__pic14)
+  __asm
+    BSF   STATUS,RP0
+    MOVF  TRISA,W
+    BCF   STATUS,RP0
+    MOVWF _test_tris
+  __endasm;
+#else   // !defined(__pic14)
+  __asm
+    BANKSEL _TRISA
+    MOVF    _TRISA,W
+    BANKSEL _test_tris
+    MOVWF   _test_tris
+  __endasm;
+#endif  // !defined(__pic14)
+
+  if(test_tris != 0x0f)
+    failures++;
+
+  done();
+}
diff --git a/src/regression/mult1.c b/src/regression/mult1.c
new file mode 100644
index 0000000..bcf9c71
--- /dev/null
+++ b/src/regression/mult1.c
@@ -0,0 +1,108 @@
+#include "gpsim_assert.h"
+
+#define TESTLIT 0x05
+
+unsigned char failures=0;
+
+
+signed char c1,c2,c3;
+unsigned char uc1,uc2,uc3;
+
+unsigned int ui1,ui2,ui3;
+signed int i1,i2;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void m1(void)
+{
+
+  c1 = c1*5;       // char = char * lit
+
+  c2 = c1 *c3;     // char = char * char
+
+  uc1= uc1*5;      // uchar = uchar * lit
+  uc2=uc1*uc3;     // uchar = uchar * uchar
+
+  if(c2 != 25)
+    failures++;
+}
+
+void m2(unsigned char uc)
+{
+
+  uc2 = uc1 * uc;
+
+  if(uc2 != 0x20)
+    failures++;
+}
+
+void m3(unsigned char uc)
+{
+  volatile unsigned char vuc;
+  
+  // uchar = uchar * lit
+  // testing literal multiply with same source and destination
+  vuc = uc;
+  uc2 = 0;   
+  uc1 = vuc; uc1 = uc1*1; if( uc1 != (uc2+=TESTLIT) ) failures++; 
+  uc1 = vuc; uc1 = uc1*2; if( uc1 != (uc2+=TESTLIT) ) failures++;      
+  uc1 = vuc; uc1 = uc1*3; if( uc1 != (uc2+=TESTLIT) ) failures++;     
+  uc1 = vuc; uc1 = uc1*4; if( uc1 != (uc2+=TESTLIT) ) failures++;      
+  uc1 = vuc; uc1 = uc1*5; if( uc1 != (uc2+=TESTLIT) ) failures++;     
+  uc1 = vuc; uc1 = uc1*6; if( uc1 != (uc2+=TESTLIT) ) failures++;      
+  uc1 = vuc; uc1 = uc1*7; if( uc1 != (uc2+=TESTLIT) ) failures++;     
+  uc1 = vuc; uc1 = uc1*8; if( uc1 != (uc2+=TESTLIT) ) failures++;      
+  uc1 = vuc; uc1 = uc1*9; if( uc1 != (uc2+=TESTLIT) ) failures++;     
+  uc1 = vuc; uc1 = uc1*10; if( uc1 != (uc2+=TESTLIT) ) failures++;      
+  uc1 = vuc; uc1 = uc1*11; if( uc1 != (uc2+=TESTLIT) ) failures++;     
+  uc1 = vuc; uc1 = uc1*12; if( uc1 != (uc2+=TESTLIT) ) failures++;      
+  uc1 = vuc; uc1 = uc1*13; if( uc1 != (uc2+=TESTLIT) ) failures++;
+  uc1 = vuc; uc1 = uc1*14; if( uc1 != (uc2+=TESTLIT) ) failures++;
+  uc1 = vuc; uc1 = uc1*15; if( uc1 != (uc2+=TESTLIT) ) failures++;
+  uc1 = vuc; uc1 = uc1*16; if( uc1 != (uc2+=TESTLIT) ) failures++;
+  uc1 = vuc; uc1 = uc1*17; if( uc1 != (uc2+=TESTLIT) ) failures++;
+  uc1 = vuc; uc1 = uc1*18; if( uc1 != (uc2+=TESTLIT) ) failures++;
+  uc1 = vuc; uc1 = uc1*19; if( uc1 != (uc2+=TESTLIT) ) failures++;
+  uc1 = vuc; uc1 = uc1*20; if( uc1 != (uc2+=TESTLIT) ) failures++;
+  uc1 = vuc; uc1 = uc1*21; if( uc1 != (uc2+=TESTLIT) ) failures++;
+  uc1 = vuc; uc1 = uc1*22; if( uc1 != (uc2+=TESTLIT) ) failures++;
+  uc1 = vuc; uc1 = uc1*23; if( uc1 != (uc2+=TESTLIT) ) failures++;  
+  uc1 = vuc; uc1 = uc1*24; if( uc1 != (uc2+=TESTLIT) ) failures++;
+  
+  uc1 = vuc; uc1 = uc1*31; if( uc1 != ((31*TESTLIT) & 0xff) ) failures++;
+  uc1 = vuc; uc1 = uc1*32; if( uc1 != ((32*TESTLIT) & 0xff) ) failures++;
+  uc1 = vuc; uc1 = uc1*64; if( uc1 != ((64*TESTLIT) & 0xff) ) failures++;
+  uc1 = vuc; uc1 = uc1*128;if( uc1 != ((128*TESTLIT)& 0xff) ) failures++;
+
+  // testing literal multiply with different source and destination
+  uc1 = vuc*1; if( uc1 != ((1*TESTLIT) & 0xff) ) failures++;    
+  uc1 = vuc*2; if( uc1 != ((2*TESTLIT) & 0xff) ) failures++;    
+  uc1 = vuc*4; if( uc1 != ((4*TESTLIT) & 0xff) ) failures++;
+}
+
+
+void main(void)
+{
+  c1 = 1;
+  c3 = 5;
+
+  m1();
+
+  uc1 = 0x10;
+  m2(2);
+
+  ui1 = uc1*uc2;   // uint = uchar * uchar
+
+  i1 = c1*c2;      // int = char * char
+
+  ui3 = ui1*ui2;   // uint = uint * unit
+
+  //m3(TESTLIT);
+
+  done();
+}
diff --git a/src/regression/nestfor.c b/src/regression/nestfor.c
new file mode 100644
index 0000000..654efe8
--- /dev/null
+++ b/src/regression/nestfor.c
@@ -0,0 +1,139 @@
+#include "gpsim_assert.h"
+#include "picregs.h"
+
+unsigned char failures=0;
+
+unsigned int uint0 = 0;
+unsigned int uint1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+
+void dput(unsigned char val)
+{
+	PORTB = val;
+	PORTA = 0x01;
+	PORTA = 0x00;
+}
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+/* both loops use the loop variable inside the inner loop */
+void for1(void)
+{
+	unsigned char i, j;
+
+	uchar0 = 0;
+	uchar1 = 0;
+	for(i = 0; i < 3; i++) {
+		uchar0++;
+		for(j = 0; j < 4; j++) {
+			uchar1++;
+			dput(i);
+			dput(j);
+		}
+	}
+	if(uchar0 != 3)
+		failures++;
+	if(uchar1 != 12)
+		failures++;
+}
+
+/* only the outer loop's variable is used inside, inner can be optimized into a repeat-loop */
+void for2(void)
+{
+	unsigned char i, j;
+
+	uchar0 = 0;
+	uchar1 = 0;
+	for(i = 0; i < 3; i++) {
+		uchar0++;
+		for(j = 0; j < 4; j++) {
+			uchar1++;
+			dput(i);
+		}
+	}
+	if(uchar0 != 3)
+		failures++;
+	if(uchar1 != 12)
+		failures++;
+}
+
+/* only the inner loop's variable is used inside */
+void for3(void)
+{
+	unsigned char i, j;
+
+	uchar0 = 0;
+	uchar1 = 0;
+	for(i = 0; i < 3; i++) {
+		uchar0++;
+		for(j = 0; j < 4; j++) {
+			uchar1++;
+			dput(j);
+		}
+	}
+	if(uchar0 != 3)
+		failures++;
+	if(uchar1 != 12)
+		failures++;
+
+}
+
+/* neither loop variable used inside the loops */
+void for4(void)
+{
+	unsigned char i, j;
+
+	uchar0 = 0;
+	uchar1 = 0;
+	for(i = 0; i < 3; i++) {
+		uchar0++;
+		for(j = 0; j < 4; j++) {
+			uchar1++;
+			dput(uchar0);
+			dput(uchar1);
+		}
+	}
+	if(uchar0 != 3)
+		failures++;
+	if(uchar1 != 12)
+		failures++;
+
+}
+
+/* like for1 but different condition in inner loop */
+void for5(void)
+{
+	unsigned char i, j;
+
+	uchar0 = 0;
+	uchar1 = 0;
+	for(i = 0; i < 3; i++) {
+		uchar0++;
+		for(j = 10; j >= 5; j--) {
+			uchar1++;
+			dput(i);
+			dput(j);
+		}
+	}
+	if(uchar0 != 3)
+		failures++;
+	if(uchar1 != 18)
+		failures++;
+}
+
+void main(void)
+{
+  for1();
+  for2();
+  for3();
+  for4();
+  for5();
+
+  done();
+}
diff --git a/src/regression/or1.c b/src/regression/or1.c
new file mode 100644
index 0000000..b828eb0
--- /dev/null
+++ b/src/regression/or1.c
@@ -0,0 +1,198 @@
+#include "gpsim_assert.h"
+
+/* bit types are not ANSI - so provide a way of disabling bit types
+ * if this file is used to test other compilers besides SDCC */
+#define SUPPORT_BIT_TYPES 0
+
+unsigned char failures=0;
+
+#if SUPPORT_BIT_TYPES
+bit bit0 = 0;
+bit bit1 = 0;
+bit bit2 = 0;
+#endif
+
+unsigned int uint0 = 0;
+unsigned int uint1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+unsigned long ulong0 = 0;
+unsigned long ulong1 = 0;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+// uchar0 = 0;
+void or_lit2uchar(void)
+{
+
+  if(uchar0)
+    failures++;
+
+  uchar0 |= 1;
+
+  if(uchar0 != 1)
+    failures++;
+
+  uchar0 |= 2;
+
+  if(uchar0 != 3)
+    failures++;
+
+  uchar0 |= 0x0e;
+
+  if(uchar0 != 0x0f)
+    failures++;
+
+}
+
+
+void or_lit2uint(void)
+{
+
+  if(uint0)
+    failures++;
+
+  uint0 |= 1;
+  if(uint0 != 1) 
+    failures++;
+
+  uint0 |= 2;
+  if(uint0 != 3) 
+    failures++;
+
+  uint0 |= 0x100;
+  if(uint0 != 0x103) 
+    failures++;
+
+  uint0 |= 0x102;
+  if(uint0 != 0x103) 
+    failures++;
+
+  uint0 |= 0x303;
+  if(uint0 != 0x303) 
+    failures++;
+
+}
+
+void or_lit2ulong(void)
+{
+
+  if(ulong0)
+    failures++;
+
+  ulong0 |= 1;
+  if(ulong0 != 1) 
+    failures++;
+
+  ulong0 |= 2;
+  if(ulong0 != 3) 
+    failures++;
+
+  ulong0 |= 0x100;
+  if(ulong0 != 0x103) 
+    failures++;
+
+  ulong0 |= 0x102;
+  if(ulong0 != 0x103) 
+    failures++;
+
+  ulong0 |= 0x303;
+  if(ulong0 != 0x303) 
+    failures++;
+
+  ulong0 |= 0x80000000;
+  if(ulong0 != 0x80000303) 
+    failures++;
+
+}
+
+/*-----------*/
+void or_uchar2uchar(void)
+{
+
+  uchar0 |= uchar1;
+
+  if(uchar0 != 1)
+    failures++;
+
+  uchar1 |= 0x0f;
+
+  uchar0 = uchar1 | 0x10;
+
+  if(uchar0 != 0x1f)
+    failures++;
+}
+
+void or_uint2uint(void)
+{
+  uint0 |= uint1;
+
+  if(uint0 != 1)
+    failures++;
+
+  uint1 |= 0x0f;
+
+  uint0 = uint1 | 0x10;
+
+  if(uint0 != 0x1f)
+    failures++;
+
+}
+
+#if SUPPORT_BIT_TYPES
+void or_bits1(void)
+{
+
+  bit0 = bit0 | bit1 | bit2;
+
+}
+
+void or_bits2(void)
+{
+
+  bit0 = bit1 | bit2;
+
+}
+#endif
+
+void main(void)
+{
+
+  or_lit2uchar();
+  or_lit2uint();
+  or_lit2ulong();
+
+  uchar0=0;
+  uchar1=1;
+  or_uchar2uchar();
+
+  uint0=0;
+  uint1=1;
+  or_uint2uint();
+
+#if SUPPORT_BIT_TYPES
+  or_bits1();
+  if(bit0)
+    failures++;
+
+  or_bits2();
+  if(bit0)
+    failures++;
+
+  bit1=1;
+  or_bits1();
+  if(!bit0)
+    failures++;
+
+  or_bits2();
+  if(!bit0)
+    failures++;
+#endif
+
+  done();
+}
diff --git a/src/regression/pcodeopt.c b/src/regression/pcodeopt.c
new file mode 100644
index 0000000..8be5a2a
--- /dev/null
+++ b/src/regression/pcodeopt.c
@@ -0,0 +1,26 @@
+#include "gpsim_assert.h"
+
+/*
+ * Test for buggy pCode optimization on
+ *    CLRF reg	; pc1
+ *    ...
+ *    MOVF reg,W	; pc2
+ *
+ * Originally, both instructions were removed and pc2 replaced with
+ *    CLRF reg          iff reg was used afterwards, but Z and W were not, or
+ *    MOVLW 0           iff reg and Z were not used afterwards, but W was.
+ * Detection of W being used used to be buggy, though...
+ */
+signed int x=0;
+unsigned char y=1;
+
+void main() {
+    x += y;
+    x += y;
+    if (x != 2) { FAILED(); }
+    if (y != 1) { FAILED(); }
+    //ASSERT(MANGLE(x) == 2);
+    //ASSERT(MANGLE(y) == 1);
+    PASSED();
+}
+
diff --git a/src/regression/picregs.h b/src/regression/picregs.h
new file mode 100644
index 0000000..92c20a9
--- /dev/null
+++ b/src/regression/picregs.h
@@ -0,0 +1,10 @@
+#ifndef PICREGS_H
+
+#if defined(__pic16)
+  #include <pic18fregs.h>
+#else
+  #include <pic14regs.h>
+#endif
+
+#endif
+
diff --git a/src/regression/pointer1.c b/src/regression/pointer1.c
new file mode 100644
index 0000000..23075b4
--- /dev/null
+++ b/src/regression/pointer1.c
@@ -0,0 +1,134 @@
+#include "gpsim_assert.h"
+
+// Pointer tests
+
+unsigned char failures = 0;
+unsigned char dummy;
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char *acharP = 0;
+
+unsigned char buff[10];
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void
+f1 (unsigned char *ucP)
+{
+
+  if (ucP == 0)
+    {
+      failures++;
+      return;
+    }
+
+  if (*ucP)
+    failures++;
+}
+
+void
+f2 (unsigned int *uiP)
+{
+
+  if (uiP == 0)
+    {
+      failures++;
+      return;
+    }
+
+  if (*uiP)
+    failures++;
+
+}
+
+
+unsigned char *
+f3 (void)
+{
+
+  return &achar0;
+}
+
+
+void f4(unsigned char *ucP, unsigned char uc)
+{
+
+  if(!ucP) {
+    failures++;
+    return;
+  }
+
+  if(*ucP != uc)
+    failures++;
+
+}
+
+void init_array(char start_value)
+{
+  unsigned char c;
+
+  for(c=0; c<sizeof(buff); c++)
+    buff[c] = start_value++;
+
+}
+
+void check_array(char base_value)
+{
+  unsigned char c;
+
+  for(c=0; c<sizeof(buff); c++)
+    if(buff[c] != (base_value+c))
+      failures++;
+
+}
+
+void index_by_pointer(unsigned char *index, unsigned char expected_value)
+{
+  if(buff[*index] != expected_value)
+    failures++;
+}
+
+
+void
+main (void)
+{
+
+  init_array(4);
+  check_array(4);
+
+  if(buff[achar0 + 7] != 4+7)
+    failures++;
+
+  dummy = buff[achar0];
+
+  if(dummy != 4)
+    failures++;
+
+  if(dummy != (buff[achar0+1] -1)) 
+    failures++;
+
+  index_by_pointer(&dummy, 8);
+
+  f1 (&achar0);
+  f2 (&aint0);
+
+  acharP = f3 ();
+  if ((acharP == 0) || (*acharP))
+    failures++;
+  achar0 = 42;
+  if(*acharP != 42)
+    failures++;
+
+  achar0 = 5;
+  f4(&achar0, achar0);
+
+  done ();
+}
diff --git a/src/regression/ptrarg.c b/src/regression/ptrarg.c
new file mode 100644
index 0000000..ac0dc23
--- /dev/null
+++ b/src/regression/ptrarg.c
@@ -0,0 +1,39 @@
+#include "gpsim_assert.h"
+
+// Pointer to argumet tests
+#define VALUE 0x1234
+
+unsigned char failures = 0;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void
+f2(int *p1)
+{
+  int t = *p1;
+
+  if (t != VALUE)
+    ++failures;
+
+  if (*p1 != VALUE)
+    ++failures;
+}
+
+void
+f1(int p1)
+{
+  f2(&p1);
+}
+
+void
+main (void)
+{
+  f1 (VALUE);
+
+  done ();
+}
diff --git a/src/regression/ptrfunc.c b/src/regression/ptrfunc.c
new file mode 100644
index 0000000..317b19f
--- /dev/null
+++ b/src/regression/ptrfunc.c
@@ -0,0 +1,106 @@
+#include "gpsim_assert.h"
+
+unsigned char failures=0;
+
+unsigned int uint0 = 0;
+unsigned int uint1 = 0;
+
+/* 
+ * BUG: if these aren't volatile, an overzealous optimizer or somthing
+ * wreaks havoc with the simple tests like "if(uchar != 3)failures++"
+ */
+volatile unsigned char uchar0 = 0;
+volatile unsigned char uchar1 = 0;
+volatile unsigned char uchar2 = 0;
+
+void (*pfunc)();
+void (*p1func)();
+unsigned char (*pcfunc)();
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void call0(void)
+{
+	uchar0++;
+}
+
+void call1(void)
+{
+	uchar1++;
+}
+
+unsigned char call2(void)
+{
+	return uchar0 + 9;
+}
+
+void docall0(void)
+{
+	pfunc = call0;
+	(pfunc)();
+	if(uchar0 != 1)
+		failures++;
+}
+
+void docall1()
+{
+	unsigned char i;
+	for(i = 0; i < 3; i++) {
+		(*p1func)();
+	}
+}
+
+void docall2( void(*pf)() )
+{
+	unsigned char i;
+	for(i = 0; i < 2; i++) {
+		pf();
+	}
+}
+
+void main(void)
+{
+	docall0();
+
+
+	p1func = call1;
+	docall1();
+	if(uchar1 != 3)
+		failures++;
+	if(uchar0 != 1)
+		failures++;
+
+	p1func = call0;
+	docall1();
+	if(uchar1 != 3)
+		failures++;
+	if(uchar0 != 4)
+		failures++;
+
+	docall2(call0);
+	if(uchar1 != 3)
+		failures++;
+	if(uchar0 != 6)
+		failures++;
+
+	docall2(call1);
+	if(uchar1 != 5)
+		failures++;
+	if(uchar0 != 6)
+		failures++;
+
+ 	pcfunc = call2;
+ 	uchar2 = (*pcfunc)();
+	if(uchar2 != 15)
+		failures++;
+/**/
+/* 	uchar2 += (pcfunc)(); */ /* FRONT-END BUG? - type-mismatch error */
+/*	uchar2 += pcfunc(); */ /* FRONT-END BUG? - type-mismatch error */
+
+	done();
+}
diff --git a/src/regression/rotate1.c b/src/regression/rotate1.c
new file mode 100644
index 0000000..6d909d4
--- /dev/null
+++ b/src/regression/rotate1.c
@@ -0,0 +1,207 @@
+#include "gpsim_assert.h"
+
+unsigned char failures=0;
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char achar2 = 0;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void check(void)
+{
+  if(achar0 != achar1)
+    failures++;
+}
+
+void shift_left_1(void)
+{
+
+  achar0 <<= 1;
+
+  check();
+}
+
+void shift_left_2(void)
+{
+
+  achar0 <<= 2;
+
+  if(achar0 != achar1)
+    failures++;
+}
+
+
+void shift_left_3(void)
+{
+
+  achar0 <<= 3;
+
+  if(achar0 != achar1)
+    failures++;
+}
+
+void shift_left_4(void)
+{
+
+  achar0 <<= 4;
+
+  if(achar0 != achar1)
+    failures++;
+}
+
+void shift_left_5(void)
+{
+
+  achar0 <<= 5;
+
+  if(achar0 != achar1)
+    failures++;
+}
+
+void shift_left_6(void)
+{
+
+  achar0 <<= 6;
+
+  if(achar0 != achar1)
+    failures++;
+}
+
+void shift_left_7(void)
+{
+
+  achar0 <<= 7;
+
+  if(achar0 != achar1)
+    failures++;
+}
+
+void shift_right_1(void)
+{
+
+  achar0 >>= 1;
+
+  check();
+}
+
+void shift_right_2(void)
+{
+
+  achar0 >>= 2;
+
+  check();
+}
+
+void shift_right_3(void)
+{
+
+  achar0 >>= 3;
+
+  check();
+}
+
+void shift_right_4(void)
+{
+
+  achar0 >>= 4;
+
+  check();
+}
+
+void shift_right_5(void)
+{
+
+  achar0 >>= 5;
+
+  check();
+}
+
+void shift_right_6(void)
+{
+
+  achar0 >>= 6;
+
+  check();
+}
+
+void shift_right_7(void)
+{
+
+  achar0 >>= 7;
+
+  check();
+}
+
+
+void main(void)
+{
+
+  // call with both values zero
+  shift_left_1();
+
+  achar0 = 1;
+  achar1 = 2;
+  for(achar2=0; achar2<6; achar2++) {
+    shift_left_1();
+    achar1 <<=1;
+  }
+
+  achar0 = 1;
+  achar1 = 4;
+  shift_left_2();
+
+  achar0 = 1;
+  achar1 = 8;
+  shift_left_3();
+
+  achar0 = 1;
+  achar1 = 0x10;
+  shift_left_4();
+
+  achar0 = 1;
+  achar1 = 0x20;
+  shift_left_5();
+
+  achar0 = 1;
+  achar1 = 0x40;
+  shift_left_6();
+
+  achar0 = 1;
+  achar1 = 0x80;
+  shift_left_7();
+
+
+
+
+  achar0 = 2;
+  achar1 = 1;
+  shift_right_1();
+
+  achar0 = 4;
+  shift_right_2();
+
+  achar0 = 8;
+  shift_right_3();
+
+  achar0 = 0x10;
+  shift_right_4();
+
+  achar0 = 0x20;
+  shift_right_5();
+
+  achar0 = 0x40;
+  shift_right_6();
+
+  achar0 = 0x80;
+  shift_right_7();
+
+  done();
+}
diff --git a/src/regression/rotate2.c b/src/regression/rotate2.c
new file mode 100644
index 0000000..1d25110
--- /dev/null
+++ b/src/regression/rotate2.c
@@ -0,0 +1,62 @@
+#include "gpsim_assert.h"
+// Shift bytes left and right by a variable.
+
+unsigned char failures=0;
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char achar2 = 0;
+unsigned char achar3 = 0;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void shift_right_var(void)
+{
+
+  achar0 >>= achar1;
+}
+
+void shift_left_var(void)
+{
+
+  achar0 <<= achar1;
+}
+
+void shift_int_left_1(void)
+{
+
+  aint0 <<= 1;
+
+}
+
+void main(void)
+{
+  char i;
+
+  achar0 = 1;
+  achar1 = 1;
+  shift_left_var();
+
+  if(achar0 !=2)
+    failures++;
+
+  achar0 = 1;
+  achar1 = 1;
+  achar2 = 1;
+  for(i=0; i<7; i++) {
+    shift_left_var();
+    achar2 <<= 1;
+
+    if(achar2 != achar0)
+      failures++;
+  }
+
+  done();
+}
diff --git a/src/regression/rotate3.c b/src/regression/rotate3.c
new file mode 100644
index 0000000..70aab09
--- /dev/null
+++ b/src/regression/rotate3.c
@@ -0,0 +1,388 @@
+#include "gpsim_assert.h"
+// Shift ints left and right
+
+unsigned char failures=0;
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char achar2 = 0;
+unsigned char achar3 = 0;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void shift_int_left_1(void)
+{
+
+  aint0 <<= 1;
+
+}
+
+void shift_int_left_2(void)
+{
+
+  aint0 <<= 2;
+
+}
+
+void shift_int_left_3(void)
+{
+
+  aint0 <<= 3;
+
+}
+
+void shift_int_left_4(void)
+{
+
+  aint0 <<= 4;
+
+}
+
+void shift_int_left_5(void)
+{
+
+  aint0 <<= 5;
+
+}
+
+void shift_int_left_6(void)
+{
+
+  aint0 <<= 6;
+
+}
+
+void shift_int_left_7(void)
+{
+
+  aint0 <<= 7;
+
+}
+
+void shift_int_left_8(void)
+{
+
+  aint0 <<= 8;
+
+}
+
+void shift_int_left_9(void)
+{
+
+  aint0 <<= 9;
+
+}
+
+void shift_int_left_10(void)
+{
+
+  aint0 <<= 10;
+
+}
+
+void shift_int_left_11(void)
+{
+
+  aint0 <<= 11;
+
+}
+
+void shift_int_left_12(void)
+{
+
+  aint0 <<= 12;
+
+}
+
+void shift_int_left_13(void)
+{
+
+  aint0 <<= 13;
+
+}
+
+void shift_int_left_14(void)
+{
+
+  aint0 <<= 14;
+
+}
+
+void shift_int_left_15(void)
+{
+
+  aint0 <<= 15;
+
+}
+
+/*****************************************************/
+void shift_int_right_1(void)
+{
+  aint0 >>= 1;
+}
+
+void shift_int_right_2(void)
+{
+  aint0 >>= 2;
+}
+
+void shift_int_right_3(void)
+{
+  aint0 >>= 3;
+}
+
+void shift_int_right_4(void)
+{
+  aint0 >>= 4;
+}
+
+void shift_int_right_5(void)
+{
+  aint0 >>= 5;
+}
+
+void shift_int_right_6(void)
+{
+  aint0 >>= 6;
+}
+
+void shift_int_right_7(void)
+{
+  aint0 >>= 7;
+}
+
+void shift_int_right_8(void)
+{
+  aint0 >>= 8;
+}
+
+void shift_int_right_9(void)
+{
+  aint0 >>= 9;
+}
+
+void shift_int_right_10(void)
+{
+  aint0 >>= 10;
+}
+
+void shift_int_right_11(void)
+{
+  aint0 >>= 11;
+}
+
+void shift_int_right_12(void)
+{
+  aint0 >>= 12;
+}
+
+void shift_int_right_13(void)
+{
+  aint0 >>= 13;
+}
+
+void shift_int_right_14(void)
+{
+  aint0 >>= 14;
+}
+
+void shift_int_right_15(void)
+{
+  aint0 >>= 15;
+}
+
+/*****************************************************/
+void main(void)
+{
+  //char i;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_1();
+  if(aint0 != 0x579a)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_2();
+  if(aint0 != 0xaf34)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_3();
+  if(aint0 != 0x5e68)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_4();
+  if(aint0 != 0xbcd0)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_5();
+  if(aint0 != 0x79a0)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_6();
+  if(aint0 != 0xf340)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_7();
+  if(aint0 != 0xe680)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_8();
+  if(aint0 != 0xcd00)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_9();
+  if(aint0 != 0x9a00)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_10();
+  if(aint0 != 0x3400)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_11();
+  if(aint0 != 0x6800)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_12();
+  if(aint0 != 0xd000)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_13();
+  if(aint0 != 0xa000)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_14();
+  if(aint0 != 0x4000)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_15();
+  if(aint0 != 0x8000)
+    failures++;
+
+  /***********************/
+  aint0 = 0xabcd;
+
+  shift_int_right_1();
+  if(aint0 != 0x55e6)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_2();
+  if(aint0 != 0x2af3)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_3();
+  if(aint0 != 0x1579)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_4();
+  if(aint0 != 0x0abc)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_5();
+  if(aint0 != 0x055e)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_6();
+  if(aint0 != 0x02af)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_7();
+  if(aint0 != 0x0157)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_8();
+  if(aint0 != 0x00ab)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_9();
+  if(aint0 != 0x0055)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_10();
+  if(aint0 != 0x002a)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_11();
+  if(aint0 != 0x0015)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_12();
+  if(aint0 != 0x000a)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_13();
+  if(aint0 != 0x0005)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_14();
+  if(aint0 != 0x0002)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_15();
+  if(aint0 != 0x0001)
+    failures++;
+
+  done();
+}
diff --git a/src/regression/rotate4.c b/src/regression/rotate4.c
new file mode 100644
index 0000000..8d8f6f5
--- /dev/null
+++ b/src/regression/rotate4.c
@@ -0,0 +1,223 @@
+#include "gpsim_assert.h"
+// rotate bytes left and right by a constant.
+
+unsigned char failures=0;
+
+unsigned int uint0 = 0;
+unsigned int uint1 = 0;
+unsigned char uchar0 = 0;
+unsigned char uchar1 = 0;
+unsigned char uchar2 = 0;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void check(void)
+{
+  if(uchar0 != uchar1)
+    failures++;
+}
+
+void rotate_left_1(void)
+{
+
+  uchar0 = (uchar0<<1) | (uchar0>>7);
+
+  check();
+}
+
+void rotate_left_2(void)
+{
+
+  uchar0 = (uchar0<<2) | (uchar0>>6);
+
+  check();
+}
+
+
+void rotate_left_3(void)
+{
+
+  uchar0 <<= 3;
+
+  if(uchar0 != uchar1)
+    failures++;
+}
+
+void rotate_left_4(void)
+{
+
+  uchar0 <<= 4;
+
+  if(uchar0 != uchar1)
+    failures++;
+}
+
+void rotate_left_5(void)
+{
+
+  uchar0 <<= 5;
+
+  if(uchar0 != uchar1)
+    failures++;
+}
+
+void rotate_left_6(void)
+{
+
+  uchar0 <<= 6;
+
+  if(uchar0 != uchar1)
+    failures++;
+}
+
+void rotate_left_7(void)
+{
+
+  uchar0 <<= 7;
+
+  if(uchar0 != uchar1)
+    failures++;
+}
+
+void rotate_right_1(void)
+{
+
+  uchar0 = (uchar0>>1) | (uchar0<<7);
+
+  check();
+
+}
+
+void rotate_right_2(void)
+{
+
+  uchar0 = (uchar0>>2) | (uchar0<<6);
+
+  check();
+}
+
+void rotate_right_3(void)
+{
+
+  uchar0 >>= 3;
+
+  check();
+}
+
+void rotate_right_4(void)
+{
+
+  uchar0 >>= 4;
+
+  check();
+}
+
+void rotate_right_5(void)
+{
+
+  uchar0 >>= 5;
+
+  check();
+}
+
+void rotate_right_6(void)
+{
+
+  uchar0 >>= 6;
+
+  check();
+}
+
+void rotate_right_7(void)
+{
+
+  uchar0 >>= 7;
+
+  check();
+}
+
+
+void main(void)
+{
+
+  // call with both values zero
+  rotate_left_1();
+
+  uchar0 = 1;
+  uchar1 = 2;
+
+  rotate_left_1();
+
+  uchar0 = 0x80;
+  uchar1 = 1;
+
+  rotate_left_1();
+
+  uchar1 = 2;
+  for(uchar2=0; uchar2<6; uchar2++) {
+    rotate_left_1();
+    uchar1 <<=1;
+  }
+
+
+  uchar0 = 1;
+  uchar1 = 4;
+  rotate_left_2();
+
+  uchar0 = 1;
+  uchar1 = 8;
+  rotate_left_3();
+
+  uchar0 = 1;
+  uchar1 = 0x10;
+  rotate_left_4();
+
+  uchar0 = 1;
+  uchar1 = 0x20;
+  rotate_left_5();
+
+  uchar0 = 1;
+  uchar1 = 0x40;
+  rotate_left_6();
+
+  uchar0 = 1;
+  uchar1 = 0x80;
+  rotate_left_7();
+
+
+
+
+  uchar0 = 2;
+  uchar1 = 1;
+  rotate_right_1();
+
+  uchar0 = 1;
+  uchar1 = 0x80;
+  rotate_right_1();
+
+  uchar0 = 4;
+  uchar1 = 1;
+  rotate_right_2();
+
+  uchar0 = 8;
+  rotate_right_3();
+
+  uchar0 = 0x10;
+  rotate_right_4();
+
+  uchar0 = 0x20;
+  rotate_right_5();
+
+  uchar0 = 0x40;
+  rotate_right_6();
+
+  uchar0 = 0x80;
+  rotate_right_7();
+
+  done();
+}
diff --git a/src/regression/rotate5.c b/src/regression/rotate5.c
new file mode 100644
index 0000000..dc5d0b2
--- /dev/null
+++ b/src/regression/rotate5.c
@@ -0,0 +1,234 @@
+#include "gpsim_assert.h"
+// Shift bytes left and right by a constant.
+
+unsigned char failures=0;
+
+signed int aint0 = 0;
+signed int aint1 = 0;
+signed char achar0 = 0;
+signed char achar1 = 0;
+signed char achar2 = 0;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void check(void)
+{
+  if(achar0 != achar1)
+    failures++;
+}
+
+void shift_left_1(void)
+{
+
+  achar0 <<= 1;
+
+  check();
+}
+
+void shift_left_2(void)
+{
+
+  achar0 <<= 2;
+
+  if(achar0 != achar1)
+    failures++;
+}
+
+
+void shift_left_3(void)
+{
+
+  achar0 <<= 3;
+
+  if(achar0 != achar1)
+    failures++;
+}
+
+void shift_left_4(void)
+{
+
+  achar0 <<= 4;
+
+  if(achar0 != achar1)
+    failures++;
+}
+
+void shift_left_5(void)
+{
+
+  achar0 <<= 5;
+
+  if(achar0 != achar1)
+    failures++;
+}
+
+void shift_left_6(void)
+{
+
+  achar0 <<= 6;
+
+  if(achar0 != achar1)
+    failures++;
+}
+
+void shift_left_7(void)
+{
+
+  achar0 <<= 7;
+
+  if(achar0 != achar1)
+    failures++;
+}
+
+void shift_right_1(void)
+{
+
+  achar0 >>= 1;
+
+  check();
+}
+
+void shift_right_2(void)
+{
+
+  achar0 >>= 2;
+
+  check();
+}
+
+void shift_right_3(void)
+{
+
+  achar0 >>= 3;
+
+  check();
+}
+
+void shift_right_4(void)
+{
+
+  achar0 >>= 4;
+
+  check();
+}
+
+void shift_right_5(void)
+{
+
+  achar0 >>= 5;
+
+  check();
+}
+
+void shift_right_6(void)
+{
+
+  achar0 >>= 6;
+
+  check();
+}
+
+void shift_right_7(void)
+{
+
+  achar0 >>= 7;
+
+  check();
+}
+
+
+void main(void)
+{
+
+  // call with both values zero
+  shift_left_1();
+
+  achar0 = 1;
+  achar1 = 2;
+  for(achar2=0; achar2<6; achar2++) {
+    shift_left_1();
+    achar1 <<=1;
+  }
+
+  achar0 = 1;
+  achar1 = 4;
+  shift_left_2();
+
+  achar0 = 1;
+  achar1 = 8;
+  shift_left_3();
+
+  achar0 = 1;
+  achar1 = 0x10;
+  shift_left_4();
+
+  achar0 = 1;
+  achar1 = 0x20;
+  shift_left_5();
+
+  achar0 = 1;
+  achar1 = 0x40;
+  shift_left_6();
+
+  achar0 = 1;
+  achar1 = 0x80;
+  shift_left_7();
+
+
+
+
+  achar0 = 2;
+  achar1 = 1;
+  shift_right_1();
+
+  achar0 = 4;
+  shift_right_2();
+
+  achar0 = 8;
+  shift_right_3();
+
+  achar0 = 0x10;
+  shift_right_4();
+
+  achar0 = 0x20;
+  shift_right_5();
+
+  achar0 = 0x40;
+  shift_right_6();
+
+
+  achar0 = 0xff;
+  achar1 = 0xff;
+  shift_right_1();
+
+  achar0 = 0xfe;
+  achar1 = 0xff;
+  shift_right_1();
+
+  achar0 = 0xfc;
+  shift_right_2();
+
+  achar0 = 0xf8;
+  shift_right_3();
+
+  achar0 = 0xf0;
+  shift_right_4();
+
+  achar0 = 0xe0;
+  shift_right_5();
+
+  achar0 = 0xc0;
+  shift_right_6();
+
+  achar0 = 0x80;
+  achar1 = 0xff;
+  shift_right_7();
+
+
+  done();
+}
diff --git a/src/regression/rotate6.c b/src/regression/rotate6.c
new file mode 100644
index 0000000..0589ae5
--- /dev/null
+++ b/src/regression/rotate6.c
@@ -0,0 +1,135 @@
+#include "gpsim_assert.h"
+// Shift bytes left and right by a variable.
+
+unsigned char failures=0;
+
+signed int aint0 = 0;
+signed int aint1 = 0;
+signed char achar0 = 0;
+signed char achar1 = 0;
+signed char achar2 = 0;
+signed char achar3 = 0;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void shift_right_var(void)
+{
+
+  achar0 >>= achar1;
+
+}
+
+void shift_left_var(void)
+{
+
+  achar0 <<= achar1;
+}
+
+void shift_int_left_var(void)
+{
+
+  aint0 <<= achar1;
+
+}
+
+void shift_int_right_var(void)
+{
+
+  aint0 >>= achar1;
+
+}
+
+void shift_int_right_var2(void)
+{
+
+  aint0 = aint1 >> achar1;
+
+}
+
+void shift_int_left_var2(void)
+{
+
+  aint0 = aint1 << achar1;
+
+}
+
+void main(void)
+{
+  char i;
+
+  achar0 = 1;
+  achar1 = 1;
+  shift_left_var();
+
+  if(achar0 !=2)
+    failures++;
+
+  achar0 = 1;
+  achar1 = 1;
+  achar2 = 1;
+  for(i=0; i<7; i++) {
+    shift_left_var();
+    achar2 <<= 1;
+
+    if(achar2 != achar0)
+      failures++;
+  }
+
+  achar1 = 4;
+  achar0 = 0xf0;
+  shift_right_var();
+  if(achar0 != (char)0xff)
+    failures++;
+
+  aint0 = 1;
+  aint1 = 1;
+  achar1 = 1;
+
+  for(i=0; i<15; i++) {
+    shift_int_left_var();
+    aint1 <<= 1;
+    if(aint0 != aint1)
+      failures++;
+  }
+
+  aint0 = 0x4000;
+  aint1 = 0x4000;
+
+  for(i=0; i<15; i++) {
+    shift_int_right_var();
+    aint1 >>= 1;
+    if(aint0 != aint1)
+      failures++;
+  }
+
+
+  aint0 = -0x4000;
+  aint1 = -0x4000;
+
+  for(i=0; i<15; i++) {
+    shift_int_right_var();
+    aint1 >>= 1;
+    if(aint0 != aint1)
+      failures++;
+  }
+
+  aint1 = 0xf000;
+  achar1 = 10;
+  shift_int_right_var2();
+
+  if(aint0 != 0xfffc)
+    failures++;
+
+  aint1 = aint0;
+  shift_int_left_var2();
+
+  if(aint0 != 0xf000)
+    failures++;
+
+  done();
+}
diff --git a/src/regression/rotate7.c b/src/regression/rotate7.c
new file mode 100644
index 0000000..1546055
--- /dev/null
+++ b/src/regression/rotate7.c
@@ -0,0 +1,388 @@
+#include "gpsim_assert.h"
+// Shift ints left and right
+
+unsigned char failures=0;
+
+signed int aint0 = 0;
+signed int aint1 = 0;
+signed char achar0 = 0;
+signed char achar1 = 0;
+signed char achar2 = 0;
+signed char achar3 = 0;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void shift_int_left_1(void)
+{
+
+  aint0 <<= 1;
+
+}
+
+void shift_int_left_2(void)
+{
+
+  aint0 <<= 2;
+
+}
+
+void shift_int_left_3(void)
+{
+
+  aint0 <<= 3;
+
+}
+
+void shift_int_left_4(void)
+{
+
+  aint0 <<= 4;
+
+}
+
+void shift_int_left_5(void)
+{
+
+  aint0 <<= 5;
+
+}
+
+void shift_int_left_6(void)
+{
+
+  aint0 <<= 6;
+
+}
+
+void shift_int_left_7(void)
+{
+
+  aint0 <<= 7;
+
+}
+
+void shift_int_left_8(void)
+{
+
+  aint0 <<= 8;
+
+}
+
+void shift_int_left_9(void)
+{
+
+  aint0 <<= 9;
+
+}
+
+void shift_int_left_10(void)
+{
+
+  aint0 <<= 10;
+
+}
+
+void shift_int_left_11(void)
+{
+
+  aint0 <<= 11;
+
+}
+
+void shift_int_left_12(void)
+{
+
+  aint0 <<= 12;
+
+}
+
+void shift_int_left_13(void)
+{
+
+  aint0 <<= 13;
+
+}
+
+void shift_int_left_14(void)
+{
+
+  aint0 <<= 14;
+
+}
+
+void shift_int_left_15(void)
+{
+
+  aint0 <<= 15;
+
+}
+
+/*****************************************************/
+void shift_int_right_1(void)
+{
+  aint0 >>= 1;
+}
+
+void shift_int_right_2(void)
+{
+  aint0 >>= 2;
+}
+
+void shift_int_right_3(void)
+{
+  aint0 >>= 3;
+}
+
+void shift_int_right_4(void)
+{
+  aint0 >>= 4;
+}
+
+void shift_int_right_5(void)
+{
+  aint0 >>= 5;
+}
+
+void shift_int_right_6(void)
+{
+  aint0 >>= 6;
+}
+
+void shift_int_right_7(void)
+{
+  aint0 >>= 7;
+}
+
+void shift_int_right_8(void)
+{
+  aint0 >>= 8;
+}
+
+void shift_int_right_9(void)
+{
+  aint0 >>= 9;
+}
+
+void shift_int_right_10(void)
+{
+  aint0 >>= 10;
+}
+
+void shift_int_right_11(void)
+{
+  aint0 >>= 11;
+}
+
+void shift_int_right_12(void)
+{
+  aint0 >>= 12;
+}
+
+void shift_int_right_13(void)
+{
+  aint0 >>= 13;
+}
+
+void shift_int_right_14(void)
+{
+  aint0 >>= 14;
+}
+
+void shift_int_right_15(void)
+{
+  aint0 >>= 15;
+}
+
+/*****************************************************/
+void main(void)
+{
+  //char i;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_1();
+  if(aint0 != 0x579a)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_2();
+  if(aint0 != 0xaf34)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_3();
+  if(aint0 != 0x5e68)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_4();
+  if(aint0 != 0xbcd0)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_5();
+  if(aint0 != 0x79a0)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_6();
+  if(aint0 != 0xf340)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_7();
+  if(aint0 != 0xe680)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_8();
+  if(aint0 != 0xcd00)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_9();
+  if(aint0 != 0x9a00)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_10();
+  if(aint0 != 0x3400)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_11();
+  if(aint0 != 0x6800)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_12();
+  if(aint0 != 0xd000)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_13();
+  if(aint0 != 0xa000)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_14();
+  if(aint0 != 0x4000)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_left_15();
+  if(aint0 != 0x8000)
+    failures++;
+
+  /***********************/
+  aint0 = 0xabcd;
+
+  shift_int_right_1();
+  if(aint0 != 0xd5e6)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_2();
+  if(aint0 != 0xeaf3)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_3();
+  if(aint0 != 0xf579)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_4();
+  if(aint0 != 0xfabc)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_5();
+  if(aint0 != 0xfd5e)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_6();
+  if(aint0 != 0xfeaf)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_7();
+  if(aint0 != 0xff57)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_8();
+  if(aint0 != 0xffab)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_9();
+  if(aint0 != 0xffd5)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_10();
+  if(aint0 != 0xffea)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_11();
+  if(aint0 != 0xfff5)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_12();
+  if(aint0 != 0xfffa)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_13();
+  if(aint0 != 0xfffd)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_14();
+  if(aint0 != 0xfffe)
+    failures++;
+
+  aint0 = 0xabcd;
+
+  shift_int_right_15();
+  if(aint0 != -1)
+    failures++;
+
+  done();
+}
diff --git a/src/regression/rt.sh b/src/regression/rt.sh
new file mode 100755
index 0000000..c256367
--- /dev/null
+++ b/src/regression/rt.sh
@@ -0,0 +1,20 @@
+# test Script
+
+USAGE="Usage: `basename $0` BASENAME"
+
+if [ $# -lt 1 ] ; then
+  echo "$USAGE"
+  exit 1
+fi
+
+# compile
+
+../../bin/sdcc -I ../../device/include/pic -c -mpic14 -pp16f877 $1.c
+
+
+# create the executable
+
+gplink --map -c -o $1.o $1.o
+./create_stc $1.cod $1.stc
+
+./simulate $1.stc garbage.log
diff --git a/src/regression/simulate b/src/regression/simulate
new file mode 100755
index 0000000..2ee28b9
--- /dev/null
+++ b/src/regression/simulate
@@ -0,0 +1,26 @@
+# SDCC test script for the PIC Port
+# 
+USAGE="Usage: `basename $0` GPSIM_SCRIPT OUTPUT"
+
+if [ $# -lt 2 ] ; then
+  echo "$USAGE"
+  exit 1
+fi
+
+if [ "$GPSIM_PATH" != "" ] ; then
+  PATH=$GPSIM_PATH:$PATH
+fi
+
+GPSIM_SCRIPT=$1
+LOGFILE=$2
+echo "Test $GPSIM_SCRIPT" | tee -a $LOGFILE
+gpsim --cli -c $GPSIM_SCRIPT | tee -a $LOGFILE |\
+sed -n -e '/running\.\.\./,$ {
+/^ *Message:/ {
+s/^ *Message:\(.*\)$/\1/p
+q
+}
+}
+$ a\
+===> FAILED
+' | tee -a $LOGFILE
diff --git a/src/regression/string1.c b/src/regression/string1.c
new file mode 100644
index 0000000..163893a
--- /dev/null
+++ b/src/regression/string1.c
@@ -0,0 +1,53 @@
+#include "gpsim_assert.h"
+#include "picregs.h"
+
+unsigned char failures=0;
+//unsigned bit bit1;
+
+typedef unsigned char byte;
+
+
+byte uchar0;
+const byte arr[] = { 1,2,8,9,0 };
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void  isr(void) __interrupt 1 __using 1
+{
+
+  if(arr[3]!=9)
+    failures++;
+  PORTB = 7;
+}
+
+void lcd1(const unsigned char *str)
+{
+  const char *p = "hello world!\r\n";
+
+  if(!str)
+    failures++;
+
+ if(str && str[2] != 'r')
+    failures++;
+
+  if(arr[3]!=9)
+    failures++;
+
+  while (1) {
+    if (0 == *p) break;
+    PORTB = *p;
+    p++;
+  }
+
+}
+
+void main(void)
+{
+  lcd1("str");
+  done();
+}
diff --git a/src/regression/struct1.c b/src/regression/struct1.c
new file mode 100644
index 0000000..99b9f21
--- /dev/null
+++ b/src/regression/struct1.c
@@ -0,0 +1,104 @@
+#include "gpsim_assert.h"
+// Addition tests
+
+/* bit types are not ANSI - so provide a way of disabling bit types
+ * if this file is used to test other compilers besides SDCC */
+#define SUPPORT_BIT_TYPES 0
+
+/* Some compilers that support bit types do not support bit arithmetic 
+ * (like bitx = bity + bitz;) */
+#define SUPPORT_BIT_ARITHMETIC 1
+
+unsigned char failures = 0;
+
+#if SUPPORT_BIT_TYPES
+
+bit bit0 = 0;
+bit bit1 = 0;
+bit bit2 = 0;
+bit bit3 = 0;
+bit bit4 = 0;
+bit bit5 = 0;
+bit bit6 = 0;
+bit bit7 = 0;
+bit bit8 = 0;
+bit bit9 = 0;
+bit bit10 = 0;
+bit bit11 = 0;
+
+#endif
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char *acharP = 0;
+
+struct chars
+  {
+    unsigned char c0, c1;
+    unsigned int  i0, i1;
+  };
+
+
+struct chars struct1;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void
+struct_test (void)
+{
+
+  if (struct1.c0 || struct1.c1)
+    failures++;
+
+  struct1.c0++;
+
+  if (struct1.c0 != 1)
+    failures++;
+}
+/*
+void
+ptr_to_struct (struct chars *p)
+{
+
+  if (p->c1)
+    failures++;
+
+
+  p->c1++;
+
+  if (p->c1 != 1)
+    failures++;
+}
+*/
+void add_chars(void)
+{
+
+  achar0 = struct1.c0 + struct1.c1;
+
+  if(achar0 != 1)
+    failures++;
+}
+
+void
+main (void)
+{
+
+
+  struct1.c0 = 0;
+  struct1.c1 = 0;
+  struct_test ();
+  //  ptr_to_struct (&struct1);
+
+  struct1.c0 = 0;
+  struct1.c1 = 1;
+  add_chars();
+
+  done ();
+}
diff --git a/src/regression/sub.c b/src/regression/sub.c
new file mode 100644
index 0000000..db28d20
--- /dev/null
+++ b/src/regression/sub.c
@@ -0,0 +1,252 @@
+#include "gpsim_assert.h"
+// Addition tests
+
+/* bit types are not ANSI - so provide a way of disabling bit types
+ * if this file is used to test other compilers besides SDCC */
+#define SUPPORT_BIT_TYPES 0
+
+/* Some compilers that support bit types do not support bit arithmetic 
+ * (like bitx = bity + bitz;) */
+#define SUPPORT_BIT_ARITHMETIC 1
+
+unsigned char failures=0;
+
+#if SUPPORT_BIT_TYPES
+
+bit bit0 = 0;
+bit bit1 = 0;
+bit bit2 = 0;
+bit bit3 = 0;
+bit bit4 = 0;
+bit bit5 = 0;
+bit bit6 = 0;
+bit bit7 = 0;
+bit bit8 = 0;
+bit bit9 = 0;
+bit bit10 = 0;
+bit bit11 = 0;
+
+#endif
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char achar2 = 0;
+unsigned char achar3 = 0;
+unsigned char *acharP = 0;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void sub_lit_from_uchar(void)
+{
+
+  achar0 = achar0 - 5;
+
+  if(achar0 != 0xfb)
+    failures++;
+
+  achar0 -= 10;
+
+  if(achar0 != 0xf1)
+    failures++;
+
+  achar0 = achar0 -1;  // Should be a decrement
+  if(achar0 != 0xf0)
+    failures++;
+
+  for(achar1 = 0; achar1 < 100; achar1++)
+    achar0 -= 2;
+
+  if(achar0 != 40)
+    failures++;
+
+}
+
+// achar0 = 1
+// achar1 = 100
+
+void sub_uchar2uchar(void)
+{
+
+  achar1 = achar1 - achar0;
+
+  if(achar1 != 99)
+    failures++;
+
+  for(achar2 = 0; achar2<7; achar2++)
+    achar1 -= achar0;
+
+  if(achar1 != 92)
+    failures++;
+
+}
+
+// assumes
+//  achar0 = 10
+//  achar1 = 32
+//  achar2, achar3 can be anything.
+
+void sub_uchar2uchar2(void)
+{
+
+
+  achar0--;
+  achar0 = achar0 - 1;
+  achar0 = achar0 - 2;
+  achar0 = achar0 - 3;
+  if(achar0 != 3)
+    failures++;
+
+
+  achar1 -= achar0;
+  if(achar1 != 29)
+    failures++;
+
+  achar2 = achar1 - achar0;
+  if(achar2 != 26)
+    failures++;
+
+
+  achar3 = achar2 - achar1 - achar0;
+  if(achar3 != 0xfa)
+    failures++;
+
+}
+
+// sub_bits
+// all bit variables are 0 upon entry.
+
+#if SUPPORT_BIT_TYPES
+void sub_bits(void)
+{
+
+  bit1 = bit0;
+
+  bit0 = 1;
+
+  if(bit1 != 0)
+    failures++;
+
+  bit1 = bit0-bit1;   // 1 - 0 => 1
+  if(bit1 != 1)
+    failures++;
+
+#if SUPPORT_BIT_ARITHMETIC
+  bit2 = bit1-bit0;   // 1 - 1 => 0
+  if(bit2)
+    failures++;
+
+  bit7 = bit4-bit5;
+  bit6 = bit4+bit5;
+  bit3 = bit4-bit5-bit6-bit7-bit0; // 0-0-0-0-1 => 1
+  if(!bit3)
+    failures++;
+#endif
+}
+
+/* sub_bit2uchar(void) - assumes bit0 = 1, achar0 = 7  */
+
+void sub_bit2uchar(void)
+{
+
+  achar0 -= bit0;
+
+  if(achar0 != 6)
+    failures++;
+
+  if(achar0 == bit0)
+    failures++;
+
+}
+
+void sub_bit2uint(void)
+{
+
+  if(aint0 != bit11)
+    failures++;
+
+  aint0 -= bit0;
+  if(aint0!=0xffff)
+    failures++;
+
+}
+#endif
+
+void sub_ucharFromLit(void)
+{
+
+  achar0 = 2 - achar0;
+
+  if(achar0 != 2)
+    failures++;
+
+
+  aint0 = 2 - aint0;
+
+  if(aint0 != 2)
+    failures++;
+
+  aint0--;
+
+  if(aint0 != 1)
+    failures++;
+
+  aint0 = 0x100 - aint0;
+
+  if(aint0 != 0xff)
+    failures++;
+
+  aint0 = 0xff00 - aint0;
+
+  if(aint0 != 0xfe01)
+    failures++;
+
+  aint0 = 0x0e01 - aint0;
+
+  if(aint0 != 0x1000)
+    failures++;
+
+  aint0 = 0x10ff - aint0;
+
+  if(aint0 != 0xff)
+    failures++;
+
+
+
+}
+
+void main(void)
+{
+
+  sub_lit_from_uchar();
+
+  achar0=1;
+  achar1=100;
+  sub_uchar2uchar();
+
+
+  achar0 = 10;
+  achar1 = 32;
+  sub_uchar2uchar2();
+
+#if SUPPORT_BIT_TYPES
+  sub_bits();
+
+  achar0 = 7;
+  bit0 = 1;
+  sub_bit2uchar();
+  sub_bit2uint();
+#endif
+
+  aint0 = 0;
+  achar0 = 0;
+  sub_ucharFromLit();
+
+  done();
+}
diff --git a/src/regression/sub2.c b/src/regression/sub2.c
new file mode 100644
index 0000000..44b54d5
--- /dev/null
+++ b/src/regression/sub2.c
@@ -0,0 +1,172 @@
+#include "gpsim_assert.h"
+// Addition tests
+
+/* bit types are not ANSI - so provide a way of disabling bit types
+ * if this file is used to test other compilers besides SDCC */
+#define SUPPORT_BIT_TYPES 0
+
+/* Some compilers that support bit types do not support bit arithmetic 
+ * (like bitx = bity + bitz;) */
+#define SUPPORT_BIT_ARITHMETIC 1
+
+unsigned char failures=0;
+
+#if SUPPORT_BIT_TYPES
+
+bit bit0 = 0;
+bit bit1 = 0;
+bit bit2 = 0;
+bit bit3 = 0;
+bit bit4 = 0;
+bit bit5 = 0;
+bit bit6 = 0;
+bit bit7 = 0;
+bit bit8 = 0;
+bit bit9 = 0;
+bit bit10 = 0;
+bit bit11 = 0;
+
+#endif
+
+int int0 = 0;
+int int1 = 0;
+char char0 = 0;
+char char1 = 0;
+char char2 = 0;
+
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void sub_int1(void)
+{
+  if(int0 != 5)
+    failures++;
+
+  if(int1 != 4)
+    failures++;
+
+  int0 = int0 - int1;
+
+  if(int0 != 1)
+    failures++;
+
+  int0 = 4 - int0;
+  if(int0 != 3)
+    failures++;
+
+  int0 = int0 - int1;
+
+  if(int0 != -1)
+    failures++;
+
+  int0 = int0 - 0xff;
+
+  if(int0 != -0x100)
+    failures++;
+
+  int0 = 0xff - int0;
+
+  if(int0 != 0x1ff)
+    failures++;
+
+
+}
+
+void sub_char_int(void)
+{
+
+  int0 = int0 - char0;
+
+  if(int0 != 3)
+    failures++;
+
+  if(int0 < char0)
+    failures++;
+
+  int0 = int0 - char0;
+
+  if(int0 != 1)
+    failures++;
+
+  if(int0 > char0)
+    failures++;
+
+
+  int0 = int0 - char0;
+  if(int0 != -1)
+    failures++;
+
+  if(int0>0)
+    failures++;
+
+}
+
+void assign_char2int(void)
+{
+
+  int0 = char0;
+  if(int0 != 0x7f)
+    failures++;
+
+  int1 = char1;
+  if(int1 != -5)
+    failures++;
+
+}
+
+
+void sub_compound_char(void)
+{
+
+  char0 = char1 - 5;
+  if(char0 != 4)
+    failures++;
+
+  if((char1 - char0 - 5) != 0)
+    failures++;
+
+}
+
+void sub_compound_int(void)
+{
+
+  int0 = int1 - 5;
+  if(int0 != 4)
+    failures++;
+
+  if((int1 - int0 - 5) != 0)
+    failures++;
+
+}
+
+void main(void)
+{
+
+  int0 = 5;
+  int1 = 4;
+
+  sub_int1();
+
+  int0 = 5;
+  int1 = 4;
+  char0 = 2;
+
+  sub_char_int();
+
+  char0 = 0x7f;
+  char1 = -5;
+  assign_char2int();
+
+  char1 = 9;
+  sub_compound_char();
+  
+  int1 = 9;
+  sub_compound_int();
+
+  done();
+}
diff --git a/src/regression/switch1.c b/src/regression/switch1.c
new file mode 100644
index 0000000..71730ea
--- /dev/null
+++ b/src/regression/switch1.c
@@ -0,0 +1,84 @@
+#include "gpsim_assert.h"
+unsigned char failures=0;
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void switch1(void)
+{
+
+
+  switch(achar0) {
+  case 0:
+    achar0 = 9;
+    break;
+  case 1:
+    achar0 = 18;
+    break;
+
+  default:
+    achar0 = 0;
+  }
+
+
+}
+
+void switch2(void)
+{
+
+  switch(achar1) {
+  case 0:    achar0 = 9;    break;
+  case 1:    achar0 = 8;    break;
+  case 2:    achar0 = 7;    break;
+  case 3:    achar0 = 6;    break;
+  case 4:    achar0 = 5;    break;
+  case 5:    achar0 = 4;    break;
+  case 6:    achar0 = 3;    break;
+  case 7:    achar0 = 2;    break;
+  case 8:    achar0 = 1;    break;
+  case 9:    achar0 = 0;    break;
+  case 10:    achar0 = 9;    break;
+  case 11:    achar0 = 8;    break;
+  case 12:    achar0 = 7;    break;
+  default:    achar0 = 0xff;    break;
+  }
+
+}
+
+void main(void)
+{
+
+  achar0 = 0;
+  switch1();
+  if(achar0 != 9)
+    failures++;
+
+  switch1();
+  if(achar0 != 0)
+    failures++;
+
+  achar0++;
+
+  switch1();
+  if(achar0 != 18)
+    failures++;
+
+  for(achar1=0; achar1<10;achar1++){
+    switch2();
+    if(achar0 != (9-achar1))
+      failures++;
+
+  }
+
+  done();
+}
diff --git a/src/regression/while.c b/src/regression/while.c
new file mode 100644
index 0000000..4429b88
--- /dev/null
+++ b/src/regression/while.c
@@ -0,0 +1,42 @@
+#include "gpsim_assert.h"
+
+unsigned char failures = 0;
+
+unsigned int aint0 = 0;
+unsigned int aint1 = 0;
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void
+while1 (void)
+{
+  unsigned char i = 10;
+
+  do
+    {
+      achar0++;
+    }
+  while (--i);
+
+  if (achar0 != 10)
+    failures++;
+
+}
+
+
+void
+main (void)
+{
+  while1 ();
+
+
+  done ();
+}
diff --git a/src/regression/xor.c b/src/regression/xor.c
new file mode 100644
index 0000000..cf5308c
--- /dev/null
+++ b/src/regression/xor.c
@@ -0,0 +1,56 @@
+#include "gpsim_assert.h"
+unsigned char failures=0;
+
+unsigned char achar0 = 0;
+unsigned char achar1 = 0;
+unsigned char achar2 = 0;
+
+void
+done()
+{
+  ASSERT(MANGLE(failures) == 0);
+  PASSED();
+}
+
+void xor_chars_0_1(void)
+{
+
+  achar2 = achar0 ^ achar1;
+
+  achar0 = achar0 ^ 0x1;
+
+  achar1 = achar0 ^ achar1 ^ 4;
+}
+
+void xor_if(void)
+{
+
+  if(achar0 ^ achar1) 
+    failures++;
+
+  achar0 ^= 0xff;
+
+  if( !(achar0 ^ achar1) ) 
+    failures++;
+
+}
+
+void main(void)
+{
+
+  xor_chars_0_1();
+
+  if(achar2)
+    failures++;
+
+  if(achar0 != 1)
+    failures++;
+
+  if(achar1 != 5)
+    failures++;
+
+  achar0 = achar1;
+  xor_if();
+
+  done();
+}