diff options
author | patacongo <patacongo@42af7a65-404d-4744-a932-0658087f49c3> | 2008-01-05 15:58:52 +0000 |
---|---|---|
committer | patacongo <patacongo@42af7a65-404d-4744-a932-0658087f49c3> | 2008-01-05 15:58:52 +0000 |
commit | 0a9f3aed7646297bcbd22a76cced732dc758bc41 (patch) | |
tree | dc93d4b95bc47f3e669e967e89551e6c9bdf5dbd /misc/pascal | |
parent | 5f6115973a95dcf812db02ecf362865c5682cbca (diff) | |
download | nuttx-0a9f3aed7646297bcbd22a76cced732dc758bc41.tar.gz nuttx-0a9f3aed7646297bcbd22a76cced732dc758bc41.tar.bz2 nuttx-0a9f3aed7646297bcbd22a76cced732dc758bc41.zip |
P-code optimizer
git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@497 42af7a65-404d-4744-a932-0658087f49c3
Diffstat (limited to 'misc/pascal')
-rw-r--r-- | misc/pascal/insn16/popt/Makefile | 92 | ||||
-rw-r--r-- | misc/pascal/insn16/popt/pcopt.c | 905 | ||||
-rw-r--r-- | misc/pascal/insn16/popt/pcopt.h | 47 | ||||
-rw-r--r-- | misc/pascal/insn16/popt/pfopt.c | 472 | ||||
-rw-r--r-- | misc/pascal/insn16/popt/pfopt.h | 54 | ||||
-rw-r--r-- | misc/pascal/insn16/popt/pjopt.c | 449 | ||||
-rw-r--r-- | misc/pascal/insn16/popt/pjopt.h | 42 | ||||
-rw-r--r-- | misc/pascal/insn16/popt/plopt.c | 249 | ||||
-rw-r--r-- | misc/pascal/insn16/popt/plopt.h | 44 | ||||
-rw-r--r-- | misc/pascal/insn16/popt/polocal.c | 300 | ||||
-rw-r--r-- | misc/pascal/insn16/popt/polocal.h | 73 | ||||
-rw-r--r-- | misc/pascal/insn16/popt/popt.c | 288 | ||||
-rw-r--r-- | misc/pascal/insn16/popt/popt.h | 52 | ||||
-rw-r--r-- | misc/pascal/insn16/popt/psopt.c | 386 | ||||
-rw-r--r-- | misc/pascal/insn16/popt/psopt.h | 54 |
15 files changed, 3507 insertions, 0 deletions
diff --git a/misc/pascal/insn16/popt/Makefile b/misc/pascal/insn16/popt/Makefile new file mode 100644 index 000000000..155ea6281 --- /dev/null +++ b/misc/pascal/insn16/popt/Makefile @@ -0,0 +1,92 @@ +############################################################################ +# insn16/prun/Makefile +# Host system makefile +# +# Copyright (C) 2008 Gregory Nutt. All rights reserved. +# Author: Gregory Nutt <spudmonkey@racsa.co.cr> +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# 1. Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in +# the documentation and/or other materials provided with the +# distribution. +# 3. Neither the name NuttX nor the names of its contributors may be +# used to endorse or promote products derived from this software +# without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS +# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED +# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. +# +############################################################################ +# +# Directories +# +POPTDIR = ${shell pwd} +INSNDIR = $(POPTDIR)/.. +PASCAL = $(POPTDIR)/../.. + +include $(PASCAL)/Make.config +include $(PASCAL)/Make.defs + +INCDIR = $(PASCAL)/include +LIBDIR = $(PASCAL)/lib +BINDIR = $(PASCAL)/bin16 + +# +# Tools +# +EXTRA_INCLUDES = -I$(INSNDIR)/include +INCLUDES += $(EXTRA_INCLUDES) +CFLAGS += $(EXTRA_INCLUDES) + +# +# Objects and targets +# +POPTSRCS = popt.c psopt.c polocal.c pcopt.c pjopt.c plopt.c pfopt.c +POPTOBJS = $(POPTSRCS:.c=.o) + +OBJS = $(POPTOBJS) +LIBS = libpoff.a libpas.a + +all: popt +.PHONY: all check_libs popt clean + +$(OBJS): %.o: %.c + $(CC) -c $(CFLAGS) $< -o $@ + +check_libs: + @if [ ! -f $(LIBDIR)/libpoff.a ] ; then \ + echo "$(LIBDIR)/libpoff.a does not exist" ; \ + exit 1 ; \ + fi + @if [ ! -f $(LIBDIR)/libpas.a ] ; then \ + echo "$(LIBDIR)/libpas.a does not exist" ; \ + exit 1 ; \ + fi + @if [ ! -f $(LIBDIR)/libinsn.a ] ; then \ + echo "$(LIBDIR)/libinsn.a does not exist" ; \ + exit 1 ; \ + fi + +$(BINDIR)/popt: check_libs $(POPTOBJS) + $(CC) -o $@ $(LDFLAGS) $(POPTOBJS) -lpas -lpoff -linsn + +popt: $(BINDIR)/popt + +clean: + $(RM) popt *.o core *~ diff --git a/misc/pascal/insn16/popt/pcopt.c b/misc/pascal/insn16/popt/pcopt.c new file mode 100644 index 000000000..5af19002c --- /dev/null +++ b/misc/pascal/insn16/popt/pcopt.c @@ -0,0 +1,905 @@ +/**********************************************************************
+ * pcopt.c
+ * Constant Expression Optimizations
+ *
+ * Copyright (C) 2008 Gregory Nutt. All rights reserved.
+ * Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ * used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ **********************************************************************/
+
+/**********************************************************************
+ * Included Files
+ **********************************************************************/
+
+#include <stdio.h>
+
+#include "keywords.h"
+#include "pdefs.h"
+#include "pinsn16.h"
+
+#include "paslib.h"
+#include "popt.h"
+#include "polocal.h"
+#include "pcopt.h"
+
+/**********************************************************************/
+
+sint16 unaryOptimize(void)
+{
+ sint16 nchanges = 0;
+ register uint16 temp;
+ register sint16 i;
+
+ TRACE(stderr, "[unaryOptimize]");
+
+ /* At least two pcodes are need to perform unary optimizations */
+
+ i = 0;
+ while (i < nops-1)
+ {
+ /* Check for a constant value being pushed onto the stack */
+
+ if ((pptr[i]->op == oPUSH) || (pptr[i]->op == oPUSHB))
+ {
+ /* Turn the oPUSHB into an oPUSH op (temporarily) */
+
+ if (pptr[i]->op == oPUSHB)
+ {
+ pptr[i]->op = oPUSH;
+ pptr[i]->arg2 = pptr[i]->arg1;
+ pptr[i]->arg1 = 0;
+ } /* end if */
+
+ switch (pptr[i+1]->op)
+ {
+ /* Delete unary operators on constants */
+ case oNEG :
+ pptr[i]->arg2 = -(pptr[i]->arg2);
+ deletePcode(i+1);
+ nchanges++;
+ break;
+
+ case oABS :
+ if (signExtend16(pptr[i]->arg2) < 0)
+ pptr[i]->arg2 = -signExtend16(pptr[i]->arg2);
+ deletePcode(i+1);
+ nchanges++;
+ break;
+
+ case oINC :
+ (pptr[i]->arg2)++;
+ deletePcode(i+1);
+ nchanges++;
+ break;
+
+ case oDEC :
+ (pptr[i]->arg2)--;
+ deletePcode(i+1);
+ nchanges++;
+ break;
+
+ case oNOT :
+ pptr[i]->arg2 = ~(pptr[i]->arg2);
+ deletePcode(i+1);
+ nchanges++;
+ break;
+
+ /* Simplify binary operations on constants */
+
+ case oADD :
+ if (pptr[i]->arg2 == 0)
+ {
+ deletePcodePair(i, (i+1));
+ nchanges++;
+ } /* end if */
+ else if (pptr[i]->arg2 == 1)
+ {
+ pptr[i+1]->op = oINC;
+ deletePcode(i);
+ nchanges++;
+ } /* end else if */
+ else if (pptr[i]->arg2 == (uint16)-1)
+ {
+ pptr[i+1]->op = oDEC;
+ deletePcode(i);
+ nchanges++;
+ } /* end else if */
+ else i++;
+ break;
+
+ case oSUB :
+ if (pptr[i]->arg2 == 0)
+ {
+ deletePcodePair(i, (i+1));
+ nchanges++;
+ } /* end if */
+ else if (pptr[i]->arg2 == 1)
+ {
+ pptr[i+1]->op = oDEC;
+ deletePcode(i);
+ nchanges++;
+ } /* end else if */
+ else if (pptr[i]->arg2 == (uint16)-1)
+ {
+ pptr[i+1]->op = oINC;
+ deletePcode(i);
+ nchanges++;
+ } /* end else if */
+ else i++;
+ break;
+
+ case oMUL :
+ case oDIV :
+ temp = 0;
+ switch (pptr[i]->arg2)
+ {
+ case 1 :
+ deletePcodePair(i, (i+1));
+ nchanges++;
+ break;
+ case 16384 : temp++;
+ case 8192 : temp++;
+ case 4096 : temp++;
+ case 2048 : temp++;
+ case 1024 : temp++;
+ case 512 : temp++;
+ case 256 : temp++;
+ case 128 : temp++;
+ case 64 : temp++;
+ case 32 : temp++;
+ case 16 : temp++;
+ case 8 : temp++;
+ case 4 : temp++;
+ case 2 : temp++;
+ pptr[i]->arg2 = temp;
+ if (pptr[i+1]->op == oMUL)
+ pptr[i+1]->op = oSLL;
+ else
+ pptr[i+1]->op = oSRA;
+ nchanges++;
+ i++;
+ break;
+
+ default :
+ i++;
+ break;
+ } /* end switch */
+ break;
+
+ case oSLL :
+ case oSRL :
+ case oSRA :
+ case oOR :
+ if (pptr[i]->arg2 == 0)
+ {
+ deletePcodePair(i, (i+1));
+ nchanges++;
+ } /* end if */
+ else i++;
+ break;
+
+ case oAND :
+ if (pptr[i]->arg2 == 0xffff)
+ {
+ deletePcodePair(i, (i+1));
+ nchanges++;
+ } /* end if */
+ else i++;
+ break;
+
+ /* Delete comparisons of constants to zero */
+
+ case oEQUZ :
+ if (pptr[i]->arg2 == 0) pptr[i]->arg2 = -1;
+ else pptr[i]->arg2 = 0;
+ deletePcode(i+1);
+ nchanges++;
+ break;
+
+ case oNEQZ :
+ if (pptr[i]->arg2 != 0)
+ pptr[i]->arg2 = -1;
+ else
+ pptr[i]->arg2 = 0;
+ deletePcode(i+1);
+ nchanges++;
+ break;
+
+ case oLTZ :
+ if (signExtend16(pptr[i]->arg2) < 0)
+ pptr[i]->arg2 = -1;
+ else
+ pptr[i]->arg2 = 0;
+ deletePcode(i+1);
+ nchanges++;
+ break;
+
+ case oGTEZ :
+ if (signExtend16(pptr[i]->arg2) >= 0)
+ pptr[i]->arg2 = -1;
+ else
+ pptr[i]->arg2 = 0;
+ deletePcode(i+1);
+ nchanges++;
+ break;
+
+ case oGTZ :
+ if (pptr[i]->arg2 > 0) pptr[i]->arg2 = -1;
+ else pptr[i]->arg2 = 0;
+ deletePcode(i+1);
+ nchanges++;
+ break;
+
+ case oLTEZ :
+ if (pptr[i]->arg2 <= 0) pptr[i]->arg2 = -1;
+ else pptr[i]->arg2 = 0;
+ deletePcode(i+1);
+ nchanges++;
+ break;
+
+ /* Simplify comparisons with certain constants */
+
+ case oEQU :
+ if (pptr[i]->arg2 == 0)
+ {
+ pptr[i+1]->op = oEQUZ;
+ deletePcode(i);
+ nchanges++;
+ } /* end if */
+ else if (pptr[i]->arg2 == 1)
+ {
+ pptr[i]->op = oDEC;
+ pptr[i]->arg2 = 0;
+ pptr[i+1]->op = oEQUZ;
+ nchanges++;
+ } /* end else if */
+ else if (signExtend16(pptr[i]->arg2) == -1)
+ {
+ pptr[i]->op = oINC;
+ pptr[i]->arg2 = 0;
+ pptr[i+1]->op = oEQUZ;
+ nchanges++;
+ } /* end else if */
+ else i++;
+ break;
+
+ case oNEQ :
+ if (pptr[i]->arg2 == 0)
+ {
+ pptr[i+1]->op = oNEQZ;
+ deletePcode(i);
+ nchanges++;
+ } /* end if */
+ else if (pptr[i]->arg2 == 1)
+ {
+ pptr[i]->op = oDEC;
+ pptr[i]->arg2 = 0;
+ pptr[i+1]->op = oNEQZ;
+ nchanges++;
+ } /* end else if */
+ else if (signExtend16(pptr[i]->arg2) == -1)
+ {
+ pptr[i]->op = oINC;
+ pptr[i]->arg2 = 0;
+ pptr[i+1]->op = oNEQZ;
+ nchanges++;
+ } /* end else if */
+ else i++;
+ break;
+
+ case oLT :
+ if (pptr[i]->arg2 == 0)
+ {
+ pptr[i+1]->op = oLTZ;
+ deletePcode(i);
+ nchanges++;
+ } /* end if */
+ else if (pptr[i]->arg2 == 1)
+ {
+ pptr[i]->op = oDEC;
+ pptr[i]->arg2 = 0;
+ pptr[i+1]->op = oLTZ;
+ nchanges++;
+ } /* end else if */
+ else if (signExtend16(pptr[i]->arg2) == -1)
+ {
+ pptr[i]->op = oINC;
+ pptr[i]->arg2 = 0;
+ pptr[i+1]->op = oLTZ;
+ nchanges++;
+ } /* end else if */
+ else i++;
+ break;
+
+ case oGTE :
+ if (pptr[i]->arg2 == 0)
+ {
+ pptr[i+1]->op = oGTEZ;
+ deletePcode(i);
+ nchanges++;
+ } /* end if */
+ else if (pptr[i]->arg2 == 1)
+ {
+ pptr[i]->op = oDEC;
+ pptr[i]->arg2 = 0;
+ pptr[i+1]->op = oGTEZ;
+ nchanges++;
+ } /* end else if */
+ else if (signExtend16(pptr[i]->arg2) == -1)
+ {
+ pptr[i]->op = oINC;
+ pptr[i]->arg2 = 0;
+ pptr[i+1]->op = oGTEZ;
+ nchanges++;
+ } /* end else if */
+ else i++;
+ break;
+
+ case oGT :
+ if (pptr[i]->arg2 == 0)
+ {
+ pptr[i+1]->op = oGTZ;
+ deletePcode(i);
+ nchanges++;
+ } /* end if */
+ else if (pptr[i]->arg2 == 1)
+ {
+ pptr[i]->op = oDEC;
+ pptr[i]->arg2 = 0;
+ pptr[i+1]->op = oGTZ;
+ nchanges++;
+ } /* end else if */
+ else if (signExtend16(pptr[i]->arg2) == -1)
+ {
+ pptr[i]->op = oINC;
+ pptr[i]->arg2 = 0;
+ pptr[i+1]->op = oGTZ;
+ nchanges++;
+ } /* end else if */
+ else i++;
+ break;
+
+ case oLTE :
+ if (pptr[i]->arg2 == 0)
+ {
+ pptr[i+1]->op = oLTEZ;
+ deletePcode(i);
+ nchanges++;
+ } /* end if */
+ else if (pptr[i]->arg2 == 1)
+ {
+ pptr[i]->op = oDEC;
+ pptr[i]->arg2 = 0;
+ pptr[i+1]->op = oLTEZ;
+ nchanges++;
+ } /* end else if */
+ else if (signExtend16(pptr[i]->arg2) == -1)
+ {
+ pptr[i]->op = oINC;
+ pptr[i]->arg2 = 0;
+ pptr[i+1]->op = oLTEZ;
+ nchanges++;
+ } /* end else if */
+ else i++;
+ break;
+
+ /* Simplify or delete condition branches on constants */
+
+ case oJEQUZ :
+ if (pptr[i]->arg2 == 0)
+ {
+ pptr[i+1]->op = oJMP;
+ deletePcode(i);
+ } /* end if */
+ else
+ deletePcodePair(i, (i+1));
+ nchanges++;
+ break;
+
+ case oJNEQZ :
+ if (pptr[i]->arg2 != 0)
+ {
+ pptr[i+1]->op = oJMP;
+ deletePcode(i);
+ } /* end if */
+ else
+ deletePcodePair(i, (i+1));
+ nchanges++;
+ break;
+
+ case oJLTZ :
+ if (signExtend16(pptr[i]->arg2) < 0)
+ {
+ pptr[i+1]->op = oJMP;
+ deletePcode(i);
+ } /* end if */
+ else
+ deletePcodePair(i, (i+1));
+ nchanges++;
+ break;
+
+ case oJGTEZ :
+ if (signExtend16(pptr[i]->arg2) >= 0)
+ {
+ pptr[i+1]->op = oJMP;
+ deletePcode(i);
+ } /* end if */
+ else
+ deletePcodePair(i, (i+1));
+ nchanges++;
+ break;
+
+ case oJGTZ :
+ if (pptr[i]->arg2 > 0)
+ {
+ pptr[i+1]->op = oJMP;
+ deletePcode(i);
+ } /* end if */
+ else
+ deletePcodePair(i, (i+1));
+ nchanges++;
+ break;
+
+ case oJLTEZ :
+ if (pptr[i]->arg2 <= 0)
+ {
+ pptr[i+1]->op = oJMP;
+ deletePcode(i);
+ } /* end if */
+ else
+ deletePcodePair(i, (i+1));
+ nchanges++;
+ break;
+
+ default :
+ i++;
+ break;
+ } /* end switch */
+
+ /* If the oPUSH instruction is still there, see if we can now */
+ /* represent it with an oPUSHB instruction */
+
+ if ((pptr[i]->op == oPUSH) && (pptr[i]->arg2 < 256))
+ {
+ pptr[i]->op = oPUSHB;
+ pptr[i]->arg1 = pptr[i]->arg2;
+ pptr[i]->arg2 = 0;
+ } /* end if */
+ } /* end if */
+
+ /* Delete multiple modifications of DSEG pointer */
+
+ else if (pptr[i]->op == oINDS)
+ {
+ if (pptr[i+1]->op == oINDS)
+ {
+ pptr[i]->arg2 += pptr[i+1]->arg2;
+ deletePcode(i+1);
+ } /* end if */
+ else i++;
+ } /* end else if */
+ else i++;
+ } /* end while */
+
+ return (nchanges);
+
+} /* end unaryOptimize */
+
+/**********************************************************************/
+
+sint16 binaryOptimize(void)
+{
+ sint16 nchanges = 0;
+ register sint16 stmp16;
+ register sint16 i;
+
+ TRACE(stderr, "[binaryOptimize]");
+
+ /* At least two pcodes are needed to perform the following binary */
+ /* operator optimizations */
+
+ i = 0;
+ while (i < nops-2)
+ {
+ if ((pptr[i]->op == oPUSH) || (pptr[i]->op == oPUSHB))
+ {
+ if ((pptr[i+1]->op == oPUSH) || (pptr[i+1]->op == oPUSHB))
+ {
+ /* Turn the oPUSHBs into an oPUSHs op (temporarily) */
+
+ if (pptr[i]->op == oPUSHB)
+ {
+ pptr[i]->op = oPUSH;
+ pptr[i]->arg2 = pptr[i]->arg1;
+ pptr[i]->arg1 = 0;
+ } /* end if */
+
+ if (pptr[i+1]->op == oPUSHB)
+ {
+ pptr[i+1]->op = oPUSH;
+ pptr[i+1]->arg2 = pptr[i+1]->arg1;
+ pptr[i+1]->arg1 = 0;
+ } /* end if */
+
+ switch (pptr[i+2]->op)
+ {
+ case oADD :
+ pptr[i]->arg2 += pptr[i+1]->arg2;
+ deletePcodePair((i+1), (i+2));
+ nchanges++;
+ break;
+
+ case oSUB :
+ pptr[i]->arg2 -= pptr[i+1]->arg2;
+ deletePcodePair((i+1), (i+2));
+ nchanges++;
+ break;
+
+ case oMUL :
+ pptr[i]->arg2 *= pptr[i+1]->arg2;
+ deletePcodePair((i+1), (i+2));
+ nchanges++;
+ break;
+
+ case oDIV :
+ stmp16 = pptr[i]->arg2 / signExtend16(pptr[i+1]->arg2);
+ pptr[i]->arg2 = stmp16;
+ deletePcodePair((i+1), (i+2));
+ nchanges++;
+ break;
+
+ case oMOD :
+ pptr[i]->arg2 %= pptr[i+1]->arg2;
+ deletePcodePair((i+1), (i+2));
+ nchanges++;
+ break;
+
+ case oSLL :
+ pptr[i]->arg2 <<= pptr[i+1]->arg2;
+ deletePcodePair((i+1), (i+2));
+ nchanges++;
+ break;
+
+ case oSRL :
+ pptr[i]->arg2 >>= pptr[i+1]->arg2;
+ deletePcodePair((i+1), (i+2));
+ nchanges++;
+ break;
+
+ case oSRA :
+ stmp16 = (((sint16)pptr[i]->arg2) >> pptr[i+1]->arg2);
+ pptr[i]->arg2 = (uint16)stmp16;
+ deletePcodePair((i+1), (i+2));
+ nchanges++;
+ break;
+
+ case oOR :
+ pptr[i]->arg2 |= pptr[i+1]->arg2;
+ deletePcodePair((i+1), (i+2));
+ nchanges++;
+ break;
+
+ case oAND :
+ pptr[i]->arg2 &= pptr[i+1]->arg2;
+ deletePcodePair((i+1), (i+2));
+ nchanges++;
+ break;
+
+ case oEQU :
+ if (pptr[i]->arg2 == pptr[i+1]->arg2) pptr[i]->arg2 = -1;
+ else pptr[i]->arg2 = 0;
+ deletePcodePair((i+1), (i+2));
+ nchanges++;
+ break;
+
+ case oNEQ :
+ if ((sint16)pptr[i]->arg2 != (sint16)pptr[i+1]->arg2)
+ pptr[i]->arg2 = -1;
+ else
+ pptr[i]->arg2 = 0;
+ deletePcodePair((i+1), (i+2));
+ nchanges++;
+ break;
+
+ case oLT :
+ if ((sint16)pptr[i]->arg2 < (sint16)pptr[i+1]->arg2)
+ pptr[i]->arg2 = -1;
+ else
+ pptr[i]->arg2 = 0;
+ deletePcodePair((i+1), (i+2));
+ nchanges++;
+ break;
+
+ case oGTE :
+ if ((sint16)pptr[i]->arg2 >= (sint16)pptr[i+1]->arg2)
+ pptr[i]->arg2 = -1;
+ else
+ pptr[i]->arg2 = 0;
+ deletePcodePair((i+1), (i+2));
+ nchanges++;
+ break;
+
+ case oGT :
+ if ((sint16)pptr[i]->arg2 > (sint16)pptr[i+1]->arg2)
+ pptr[i]->arg2 = -1;
+ else
+ pptr[i]->arg2 = 0;
+ deletePcodePair((i+1), (i+2));
+ nchanges++;
+ break;
+
+ case oLTE :
+ if ((sint16)pptr[i]->arg2 <= (sint16)pptr[i+1]->arg2)
+ pptr[i]->arg2 = -1;
+ else
+ pptr[i]->arg2 = 0;
+ deletePcodePair((i+1), (i+2));
+ nchanges++;
+ break;
+
+ default :
+ i++;
+ break;
+ } /* end switch */
+
+ /* If the oPUSH instruction is still there, see if we can now */
+ /* represent it with an oPUSHB instruction */
+
+ if (pptr[i] && (pptr[i]->op == oPUSH) && (pptr[i]->arg2 < 256))
+ {
+ pptr[i]->op = oPUSHB;
+ pptr[i]->arg1 = pptr[i]->arg2;
+ pptr[i]->arg2 = 0;
+ } /* end if */
+
+ if (pptr[i+1] && (pptr[i+1]->op == oPUSH) && (pptr[i+1]->arg2 < 256))
+ {
+ pptr[i+1]->op = oPUSHB;
+ pptr[i+1]->arg1 = pptr[i+1]->arg2;
+ pptr[i+1]->arg2 = 0;
+ } /* end if */
+ } /* end if */
+
+ /* A single (constant) pcode is sufficient to perform the */
+ /* following binary operator optimizations */
+
+ else if ((pptr[i+1]->op == oLDSH) || (pptr[i+1]->op == oLDSB) ||
+ (pptr[i+1]->op == oLAS) || (pptr[i+1]->op == oLAC))
+ {
+ /* Turn the oPUSHB into a oPUSH op (temporarily) */
+
+ if (pptr[i]->op == oPUSHB)
+ {
+ pptr[i]->op = oPUSH;
+ pptr[i]->arg2 = pptr[i]->arg1;
+ pptr[i]->arg1 = 0;
+ } /* end if */
+
+ switch (pptr[i+2]->op)
+ {
+ case oADD :
+ if (pptr[i]->arg2 == 0)
+ {
+ deletePcodePair(i, (i+2));
+ nchanges++;
+ } /* end if */
+ else if (pptr[i]->arg2 == 1)
+ {
+ pptr[i+2]->op = oINC;
+ deletePcode(i);
+ nchanges++;
+ } /* end else if */
+ else if (pptr[i]->arg2 == (uint16)-1)
+ {
+ pptr[i+2]->op = oDEC;
+ deletePcode(i);
+ nchanges++;
+ } /* end else if */
+ else i++;
+ break;
+
+ case oSUB :
+ if (pptr[i]->arg2 == 0)
+ {
+ pptr[i]->op = oNEG;
+ deletePcode(i);
+ nchanges++;
+ } /* end if */
+ else i++;
+ break;
+
+ case oMUL :
+ stmp16 = 0;
+ switch (pptr[i]->arg2)
+ {
+ case 1 :
+ deletePcodePair(i, (i+2));
+ nchanges++;
+ break;
+ case 16384 : stmp16++;
+ case 8192 : stmp16++;
+ case 4096 : stmp16++;
+ case 2048 : stmp16++;
+ case 1024 : stmp16++;
+ case 512 : stmp16++;
+ case 256 : stmp16++;
+ case 128 : stmp16++;
+ case 64 : stmp16++;
+ case 32 : stmp16++;
+ case 16 : stmp16++;
+ case 8 : stmp16++;
+ case 4 : stmp16++;
+ case 2 : stmp16++;
+ pptr[i]->op = pptr[i+1]->op;
+ pptr[i]->arg1 = pptr[i+1]->arg1;
+ pptr[i]->arg2 = pptr[i+1]->arg2;
+ pptr[i+1]->op = oPUSH;
+ pptr[i+1]->arg1 = 0;
+ pptr[i+1]->arg2 = stmp16;
+ pptr[i+2]->op = oSLL;
+ nchanges++;
+ i++;
+ break;
+
+ default :
+ i++;
+ break;
+ } /* end switch */
+ break;
+
+ case oOR :
+ if (pptr[i]->arg2 == 0)
+ {
+ deletePcodePair(i, (i+2));
+ nchanges++;
+ } /* end if */
+ else i++;
+ break;
+
+ case oAND :
+ if (pptr[i]->arg2 == 0xffff)
+ {
+ deletePcodePair(i, (i+2));
+ nchanges++;
+ } /* end if */
+ else i++;
+ break;
+
+ case oEQU :
+ if (pptr[i]->arg2 == 0)
+ {
+ pptr[i+2]->op = oEQUZ;
+ deletePcode(i);
+ nchanges++;
+ } /* end if */
+ else i++;
+ break;
+
+ case oNEQ :
+ if (pptr[i]->arg2 == 0)
+ {
+ pptr[i+2]->op = oNEQZ;
+ deletePcode(i);
+ nchanges++;
+ } /* end if */
+ else i++;
+ break;
+
+ case oLT :
+ if (pptr[i]->arg2 == 0)
+ {
+ pptr[i+2]->op = oGTEZ;
+ deletePcode(i);
+ nchanges++;
+ } /* end if */
+ else i++;
+ break;
+
+ case oGTE :
+ if (pptr[i]->arg2 == 0)
+ {
+ pptr[i+2]->op = oLTZ;
+ deletePcode(i);
+ nchanges++;
+ } /* end if */
+ else i++;
+ break;
+
+ case oGT :
+ if (pptr[i]->arg2 == 0)
+ {
+ pptr[i+2]->op = oLTEZ;
+ deletePcode(i);
+ nchanges++;
+ } /* end if */
+ else i++;
+ break;
+
+ case oLTE :
+ if (pptr[i]->arg2 == 0)
+ {
+ pptr[i+2]->op = oGTZ;
+ deletePcode(i);
+ nchanges++;
+ } /* end if */
+ else i++;
+ break;
+
+ default :
+ i++;
+ break;
+
+ } /* end switch */
+
+ /* If the oPUSH instruction is still there, see if we can now */
+ /* represent it with an oPUSHB instruction */
+
+ if ((pptr[i]->op == oPUSH) && (pptr[i]->arg2 < 256))
+ {
+ pptr[i]->op = oPUSHB;
+ pptr[i]->arg1 = pptr[i]->arg2;
+ pptr[i]->arg2 = 0;
+ } /* end if */
+ } /* end else if */
+ else i++;
+ } /* end if */
+
+ /* Misc improvements on binary operators */
+
+ else if (pptr[i]->op == oNEG)
+ {
+ /* Negation followed by add is subtraction */
+
+ if (pptr[i+1]->op == oADD)
+ {
+ pptr[i+1]->op = oSUB;
+ deletePcode(i);
+ nchanges++;
+ }
+
+ /* Negation followed by subtraction is addition */
+
+ else if (pptr[i]->op == oSUB)
+ {
+ pptr[i+1]->op = oADD;
+ deletePcode(i);
+ nchanges++;
+ }
+ else i++;
+ }
+ else i++;
+ } /* end while */
+
+ return (nchanges);
+
+} /* end binaryOptimize */
+
+/**********************************************************************/
+
diff --git a/misc/pascal/insn16/popt/pcopt.h b/misc/pascal/insn16/popt/pcopt.h new file mode 100644 index 000000000..2a38b481b --- /dev/null +++ b/misc/pascal/insn16/popt/pcopt.h @@ -0,0 +1,47 @@ +/***************************************************************************
+ * pcopt.h
+ * External Declarations associated with PCOPT.C
+ *
+ * Copyright (C) 2008 Gregory Nutt. All rights reserved.
+ * Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ * used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ***************************************************************************/
+
+#ifndef __PCOPT_H
+#define __PCOPT_H
+
+/***************************************************************************
+ * Global Function Prototypes
+ ***************************************************************************/
+
+extern sint16 unaryOptimize ( void );
+extern sint16 binaryOptimize ( void );
+
+#endif /* __PCOPT_H */
diff --git a/misc/pascal/insn16/popt/pfopt.c b/misc/pascal/insn16/popt/pfopt.c new file mode 100644 index 000000000..6e74cc90a --- /dev/null +++ b/misc/pascal/insn16/popt/pfopt.c @@ -0,0 +1,472 @@ +/********************************************************************** + * pfopt.c + * Finalization of optimized image + * + * Copyright (C) 2008 Gregory Nutt. All rights reserved. + * Author: Gregory Nutt <spudmonkey@racsa.co.cr> + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * 3. Neither the name NuttX nor the names of its contributors may be + * used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + **********************************************************************/ + +/********************************************************************** + * Included Files + **********************************************************************/ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "keywords.h" +#include "pdefs.h" +#include "podefs.h" +#include "pedefs.h" +#include "pinsn16.h" +#include "poff.h" +#include "paslib.h" +#include "pofflib.h" + +#include "popt.h" +#include "pfopt.h" +#include "pinsn.h" +#include "perr.h" + +/********************************************************************** + * Definitions + **********************************************************************/ + +/********************************************************************** + * Private Types + **********************************************************************/ + +/********************************************************************** + * Private Data + **********************************************************************/ + +/********************************************************************** + * Private Function Prototypes + **********************************************************************/ + +/********************************************************************** + * Private Inline Functions + **********************************************************************/ + +/********************************************************************** + * Private Functions + **********************************************************************/ + +/**********************************************************************/ + +static void pass1(poffHandle_t poffHandle, poffProgHandle_t poffProgHandle) +{ + OPTYPE op; + uint32 pc; + uint32 opsize; + + /* Build label / line number reference table + * + * CASE 1: LABEL + * Add label number + PC to table + * discard + * CASE 2: LINE + * genereate a line number reference + * discard + * ELSE: + * pass through with no additional action + */ + + pc = 0; + do + { + opsize = insn_GetOpCode(poffHandle, &op); + if (op.op == oLABEL) + { + poffAddToDefinedLabelTable(op.arg2, pc); + } + else if (op.op == oLINE) + { + poffAddLineNumber(poffHandle, op.arg2, op.arg1, pc); + } + else + { + insn_AddTmpOpCode(poffProgHandle, &op); + pc += opsize; + } + } + while (op.op != oEND); + + /* Replace the original program data with the new program data */ + + poffReplaceProgData(poffHandle, poffProgHandle); +} + +/**********************************************************************/ + +static void pass2(poffHandle_t poffHandle, poffProgHandle_t poffProgHandle) +{ + poffSymHandle_t poffSymHandle; + sint32 symIndex; + sint32 nchanges = 0; + + /* Get a container to temporarily hold any modifications that we + * make to the symbol table. + */ + + poffSymHandle = poffCreateSymHandle(); + if (poffSymHandle == NULL) + { + fatal(eNOMEMORY); + } + + /* Now read all of the symbols. (1) Add each undefined code reference + * to the label reference table, and (2) Change each defined code + * reference from a label to a program data section offset. + */ + + do + { + poffLibSymbol_t symbol; + symIndex = poffGetSymbol(poffHandle, &symbol); + if (symIndex >= 0) + { + if ((symbol.type == STT_PROC) || (symbol.type == STT_FUNC)) + { + /* It is a symbol associated with the program data section. + * Has is value been defined? + */ + + if ((symbol.flags & STF_UNDEFINED) != 0) + { + /* No... Add it to the list of undefined labels */ + + poffAddToUndefinedLabelTable(symbol.value, symIndex); + } + else + { + /* It is a defined symbol. In this case, we should have + * encountered its LABEL marker in the pass1 processing + * and the following look up should not fail. + */ + sint32 value = poffGetPcForDefinedLabel(symbol.value); + if (value < 0) + { + DEBUG(stdout, "Failed to find label L%04lx\n", symbol.value); + fatal(ePOFFCONFUSION); + } + else + { + /* Replace the label value with the section offset + * (pc) value. + */ + + symbol.value = value; + nchanges++; + } + } + } + + /* In either event, we will want to save the symbol in case + * we need to re-write the symbol table. + */ + + (void)poffAddTmpSymbol(poffHandle, poffSymHandle, &symbol); + } + } + while (symIndex >= 0); + + /* We any changes made to the symbol table in the temporary container? */ + + if (nchanges != 0) + { + /* Yes, update the symbol table */ + + poffReplaceSymbolTable(poffHandle, poffSymHandle); + + } + + /* Release the symbol container. */ + + poffDestroySymHandle(poffSymHandle); +} + +/**********************************************************************/ + +static void pass3(poffHandle_t poffHandle, poffProgHandle_t poffProgHandle) +{ + OPTYPE op; + uint32 pc; + uint32 opsize; + + /* Read each opcode, generate relocation information and + * replace label references with program section offsets. + * + * CASE 1: LAC + * generate RODATA relocation entry + * CASE 2: PCAL instructions + * replace label with I-space offset, OR + * generate a PROGRAM relocation entry + * CASE 3: J* instructions + * replace label with I-space offset + * CASE 4: LDS*, STS*, and LAS* instructions + * generate a STACK relocation (if imported?) + * ELSE: + * pass through with no additional action + */ + + pc = 0; + do + { + opsize = insn_GetOpCode(poffHandle, &op); + switch (op.op) + { + /* Load of an address in the rodata section */ + + case oLAC: + /* We are referencing something from the rodata section. + * No special action need be taken. + */ + break; + + /* Call to a procedure or function. */ + + case oPCAL: + { + /* Check if this is a defined label, i.e., a call to + * procedure or function in the same file. + */ + + sint32 value = poffGetPcForDefinedLabel(op.arg2); + if (value >= 0) + { + /* Yes... replace the label reference with + * a text section offset. No relocation record + * is needed in this case. The only relocation + * may be performed is a subsequent program data + * section offset. + */ + + op.arg2 = (uint16)value; + } + else + { + /* Check if this is a undefined label. This would + * occur for a call to a procedure or a function that + * is defined in some other unit file. + */ + + value = poffGetSymIndexForUndefinedLabel(op.arg2); + if (value >= 0) + { + /* Use the value zero now */ + + op.arg2 = 0; + + /* And generate a symbol-based relocation */ + + (void)poffAddRelocation(poffHandle, RLT_PCAL, value, pc); + } + else + { + DEBUG(stdout, "Failed to find call label L%04x\n", op.arg2); + fatal(ePOFFCONFUSION); + } + } + } + break; + + /* Jumps to "nearby" addresses */ + + case oJMP: /* Unconditional */ + case oJEQUZ: /* Unary comparisons with zero */ + case oJNEQZ: + case oJLTZ: + case oJGTEZ: + case oJGTZ: + case oJLTEZ: + case oJEQU: /* Binary comparisons */ + case oJNEQ: + case oJLT: + case oJGTE: + case oJGT: + case oJLTE: + { + /* Check if this is a defined label. This must be the case + * because there can be no jumps into a unit file. + */ + + sint32 value = poffGetPcForDefinedLabel(op.arg2); + if (value >= 0) + { + /* Yes... replace the label reference with + * a text section offset. No relocation record + * is needed in this case. The only relocation + * may be performed is a subsequent program data + * sectioin offset. + */ + + op.arg2 = (uint16)value; + } + else + { + DEBUG(stdout, "Failed to find jump label L%04x\n", op.arg2); + fatal(ePOFFCONFUSION); + } + } + break; + + /* References to stack via level offset */ + + case oLAS: /* Load stack address */ + case oLASX: + case oLDS: /* Load value */ + case oLDSH: + case oLDSB: + case oLDSM: + case oSTS: /* Store value */ + case oSTSH: + case oSTSB: + case oSTSM: + case oLDSX: + case oLDSXH: /* Load value indexed */ + case oLDSXB: + case oLDSXM: + case oSTSX: /* Store value indexed */ + case oSTSXH: + case oSTSXB: + case oSTSXM: + { +#warning REVISIT + } + break; + + /* Otherwise, it is not an interesting opcode */ + default: + break; + } + + /* Save the potentially modified opcode in the temporary + * program data container. + */ + + insn_AddTmpOpCode(poffProgHandle, &op); + pc += opsize; + } + while (op.op != oEND); + + /* Replace the original program data with the new program data */ + + poffReplaceProgData(poffHandle, poffProgHandle); +} + +/**********************************************************************/ + +static void pass4(poffHandle_t poffHandle) +{ + uint32 entryLabel; + sint32 entryOffset; + ubyte fileType; + + /* What kind of a file did we just process. Was it a program file? + * or was it a unit file? + */ + + fileType = poffGetFileType(poffHandle); + if (fileType == FHT_PROGRAM) + { + /* It is a program file. In this case, it must have a valid + * entry point label. Get it. + */ + + entryLabel = poffGetEntryPoint(poffHandle); + + /* Convert the label into a program data section offset */ + + entryOffset = poffGetPcForDefinedLabel(entryLabel); + if (entryOffset < 0) + { + fatal(ePOFFCONFUSION); + } + + /* Replace file header entry point with the program data + * section offset + */ + + poffSetEntryPoint(poffHandle, entryOffset); + } +} + +/********************************************************************** + * Global Functions + **********************************************************************/ + +void optFinalize(poffHandle_t poffHandle, poffProgHandle_t poffProgHandle) +{ + /* Build label / line number reference table */ + + pass1(poffHandle, poffProgHandle); + + /* Reset for next pass */ + + insn_ResetOpCodeRead(poffHandle); + insn_ResetTmpOpCodeWrite(poffProgHandle); + + /* Now process all of the symbols */ + + pass2(poffHandle, poffProgHandle); + + /* We do not use the debug function information so we do not bother + * to fixup the label references. Just discard this information. + */ + + poffDiscardDebugFuncInfo(poffHandle); + + /* Reset for next pass */ + + insn_ResetOpCodeRead(poffHandle); + + /* Generate relocation information and replace all label references + * in the code with actual program section data offsets. + */ + + pass3(poffHandle, poffProgHandle); + + /* Reset for next pass */ + + insn_ResetOpCodeRead(poffHandle); + insn_ResetTmpOpCodeWrite(poffProgHandle); + + /* Finally, replace file header entry point with the I-space offset */ + + pass4(poffHandle); + + /* Clean up after ourselves */ + + poffReleaseLabelReferences(); +} + +/**********************************************************************/ diff --git a/misc/pascal/insn16/popt/pfopt.h b/misc/pascal/insn16/popt/pfopt.h new file mode 100644 index 000000000..d792d11bf --- /dev/null +++ b/misc/pascal/insn16/popt/pfopt.h @@ -0,0 +1,54 @@ +/***************************************************************************
+ * pfopt.h
+ * External Declarations associated with pfopt.c
+ *
+ * Copyright (C) 2008 Gregory Nutt. All rights reserved.
+ * Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ * used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ***************************************************************************/
+
+#ifndef __PFOPT_H
+#define __PFOPT_H
+
+/***************************************************************************
+ * Included Files
+ ***************************************************************************/
+
+#include "pofflib.h"
+
+/***************************************************************************
+ * Global Function Prototypes
+ ***************************************************************************/
+
+extern void optFinalize(poffHandle_t poffHandle,
+ poffProgHandle_t poffProgHandle);
+
+#endif /* __PFOPT_H */
+
diff --git a/misc/pascal/insn16/popt/pjopt.c b/misc/pascal/insn16/popt/pjopt.c new file mode 100644 index 000000000..4771c72f3 --- /dev/null +++ b/misc/pascal/insn16/popt/pjopt.c @@ -0,0 +1,449 @@ +/**********************************************************************
+ * pjopt.c
+ * Branch Optimizations
+ *
+ * Copyright (C) 2008 Gregory Nutt. All rights reserved.
+ * Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ * used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ **********************************************************************/
+
+/**********************************************************************
+ * Included Files
+ **********************************************************************/
+
+#include <stdio.h>
+
+#include "keywords.h"
+#include "pdefs.h"
+#include "pinsn16.h"
+
+#include "popt.h"
+#include "polocal.h"
+#include "pjopt.h"
+
+/**********************************************************************/
+
+sint16 BranchOptimize (void)
+{
+ sint16 nchanges = 0;
+ register sint16 i;
+
+ TRACE(stderr, "[BranchOptimize]");
+
+ /* At least two pcodes are need to perform branch optimizations */
+
+ i = 0;
+ while (i < nops-1)
+ {
+ switch (pptr[i]->op)
+ {
+ case oNOT :
+ switch (pptr[i+1]->op)
+ {
+ case oJEQUZ :
+ pptr[i+1]->op = oJNEQZ;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ case oJNEQZ :
+ pptr[i+1]->op = oJEQUZ;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ default :
+ i++;
+ break;
+ } /* end switch */
+ break;
+
+ case oNEG :
+ switch (pptr[i+1]->op)
+ {
+ case oJLTZ :
+ pptr[i+1]->op = oJGTZ;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ case oJGTEZ :
+ pptr[i+1]->op = oJLTEZ;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ case oJGTZ :
+ pptr[i+1]->op = oJLTZ;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ case oJLTEZ :
+ pptr[i+1]->op = oJGTEZ;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ default :
+ i++;
+ break;
+ } /* end switch */
+ break;
+
+ case oEQU :
+ switch (pptr[i+1]->op)
+ {
+ case oNOT :
+ pptr[i]->op = oNEQ;
+ deletePcode(i+1);
+ nchanges++;
+ break;
+
+ case oJEQUZ :
+ pptr[i+1]->op = oJNEQ;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ case oJNEQZ :
+ pptr[i+1]->op = oJEQU;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ default :
+ i++;
+ break;
+ } /* end switch */
+ break;
+
+ case oNEQ :
+ switch (pptr[i+1]->op)
+ {
+ case oNOT :
+ pptr[i]->op = oEQU;
+ deletePcode(i+1);
+ nchanges++;
+ break;
+
+ case oJEQUZ :
+ pptr[i+1]->op = oJEQU;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ case oJNEQZ :
+ pptr[i+1]->op = oJNEQ;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ default :
+ i++;
+ break;
+ } /* end switch */
+ break;
+
+ case oLT :
+ switch (pptr[i+1]->op)
+ {
+ case oNOT :
+ pptr[i]->op = oGTE;
+ deletePcode(i+1);
+ nchanges++;
+ break;
+
+ case oJEQUZ :
+ pptr[i+1]->op = oJGTE;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ case oJNEQZ :
+ pptr[i+1]->op = oJLT;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ default :
+ i++;
+ break;
+ } /* end switch */
+ break;
+
+ case oGTE :
+ switch (pptr[i+1]->op)
+ {
+ case oNOT :
+ pptr[i]->op = oLT;
+ deletePcode(i+1);
+ nchanges++;
+ break;
+
+ case oJEQUZ :
+ pptr[i+1]->op = oJLT;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ case oJNEQZ :
+ pptr[i+1]->op = oJGTE;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ default :
+ i++;
+ break;
+ } /* end switch */
+ break;
+
+ case oGT :
+ switch (pptr[i+1]->op)
+ {
+ case oNOT :
+ pptr[i]->op = oLTE;
+ deletePcode(i+1);
+ nchanges++;
+ break;
+
+ case oJEQUZ :
+ pptr[i+1]->op = oJLTE;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ case oJNEQZ :
+ pptr[i+1]->op = oJGT;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ default :
+ i++;
+ break;
+ } /* end switch */
+ break;
+
+ case oLTE :
+ switch (pptr[i+1]->op)
+ {
+ case oNOT :
+ pptr[i]->op = oGT;
+ deletePcode(i+1);
+ nchanges++;
+ break;
+
+ case oJEQUZ :
+ pptr[i+1]->op = oJGT;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ case oJNEQZ :
+ pptr[i+1]->op = oJLTE;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ default :
+ i++;
+ break;
+ } /* end switch */
+ break;
+
+ case oEQUZ :
+ switch (pptr[i+1]->op)
+ {
+ case oNOT :
+ pptr[i]->op = oNEQZ;
+ deletePcode(i+1);
+ nchanges++;
+ break;
+
+ case oJEQUZ :
+ pptr[i+1]->op = oJNEQZ;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ case oJNEQZ :
+ pptr[i+1]->op = oJEQUZ;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ default :
+ i++;
+ break;
+ } /* end switch */
+ break;
+
+ case oNEQZ :
+ switch (pptr[i+1]->op)
+ {
+ case oNOT :
+ pptr[i]->op = oEQUZ;
+ deletePcode(i+1);
+ nchanges++;
+ break;
+
+ case oJEQUZ :
+ case oJNEQZ :
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ default :
+ i++;
+ break;
+ } /* end switch */
+ break;
+
+ case oLTZ :
+ switch (pptr[i+1]->op)
+ {
+ case oNOT :
+ pptr[i]->op = oGTEZ;
+ deletePcode(i+1);
+ nchanges++;
+ break;
+
+ case oJEQUZ :
+ pptr[i+1]->op = oJGTEZ;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ case oJNEQZ :
+ pptr[i+1]->op = oJLTZ;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ default :
+ i++;
+ break;
+ } /* end switch */
+ break;
+
+ case oGTEZ :
+ switch (pptr[i+1]->op)
+ {
+ case oNOT :
+ pptr[i]->op = oLTZ;
+ deletePcode(i+1);
+ nchanges++;
+ break;
+
+ case oJEQUZ :
+ pptr[i+1]->op = oJLTZ;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ case oJNEQZ :
+ pptr[i+1]->op = oJGTEZ;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ default :
+ i++;
+ break;
+ } /* end switch */
+ break;
+
+ case oGTZ :
+ switch (pptr[i+1]->op)
+ {
+ case oNOT :
+ pptr[i]->op = oLTEZ;
+ deletePcode(i+1);
+ nchanges++;
+ break;
+
+ case oJEQUZ :
+ pptr[i+1]->op = oJLTEZ;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ case oJNEQZ :
+ pptr[i+1]->op = oJGTZ;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ default :
+ i++;
+ break;
+ } /* end switch */
+ break;
+
+ case oLTEZ :
+ switch (pptr[i+1]->op)
+ {
+ case oNOT :
+ pptr[i]->op = oGTZ;
+ deletePcode(i+1);
+ nchanges++;
+ break;
+
+ case oJEQUZ :
+ pptr[i+1]->op = oJGTZ;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ case oJNEQZ :
+ pptr[i+1]->op = oJLTEZ;
+ deletePcode(i);
+ nchanges++;
+ break;
+
+ default :
+ i++;
+ break;
+ } /* end switch */
+ break;
+
+ default :
+ i++;
+ break;
+ } /* end switch */
+ } /* end while */
+ return (nchanges);
+
+} /* end BranchOptimize */
+
+/**********************************************************************/
+
diff --git a/misc/pascal/insn16/popt/pjopt.h b/misc/pascal/insn16/popt/pjopt.h new file mode 100644 index 000000000..ccb2e14b0 --- /dev/null +++ b/misc/pascal/insn16/popt/pjopt.h @@ -0,0 +1,42 @@ +/***************************************************************************
+ * pjopt.h
+ * External Declarations associated with pjopt.c
+ *
+ * Copyright (C) 2008 Gregory Nutt. All rights reserved.
+ * Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ * used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ***************************************************************************/
+
+#ifndef __PJOPT_H
+#define __PJOPT_H
+
+sint16 BranchOptimize ( void );
+
+#endif /* __PJOPT_H */
\ No newline at end of file diff --git a/misc/pascal/insn16/popt/plopt.c b/misc/pascal/insn16/popt/plopt.c new file mode 100644 index 000000000..906e35976 --- /dev/null +++ b/misc/pascal/insn16/popt/plopt.c @@ -0,0 +1,249 @@ +/**********************************************************************
+ * plopt.c
+ * Load/Store Optimizations
+ *
+ * Copyright (C) 2008 Gregory Nutt. All rights reserved.
+ * Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ * used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ **********************************************************************/
+
+/**********************************************************************
+ * Included Files
+ **********************************************************************/
+
+#include <stdio.h>
+
+#include "keywords.h"
+#include "pdefs.h"
+#include "pinsn16.h"
+
+#include "popt.h"
+#include "polocal.h"
+#include "plopt.h"
+
+/**********************************************************************/
+
+sint16 LoadOptimize(void)
+{
+ uint16 val;
+ sint16 nchanges = 0;
+ register sint16 i;
+
+ TRACE(stderr, "[LoadOptimize]");
+
+ /* At least two pcodes are need to perform Load optimizations */
+
+ i = 0;
+ while (i < nops-1)
+ {
+ switch (pptr[i]->op)
+ {
+ /* Eliminate duplicate loads */
+
+ case oLDSH :
+ if ((pptr[i+1]->op == oLDSH) &&
+ (pptr[i+1]->arg1 == pptr[i]->arg1) &&
+ (pptr[i+1]->arg2 == pptr[i]->arg2))
+ {
+ pptr[i+1]->op = oDUPH;
+ pptr[i+1]->arg1 = 0;
+ pptr[i+1]->arg2 = 0;
+ nchanges++;
+ i += 2;
+ } /* end if */
+ else i++;
+ break;
+
+ /* Convert loads indexed by a constant to unindexed loads */
+
+ case oPUSH :
+ case oPUSHB :
+ /* Get the index value */
+
+ if (pptr[i]->op == oPUSH)
+ {
+ val = pptr[i]->arg2;
+ }
+ else
+ {
+ val = pptr[i]->arg1;
+ }
+
+ /* If the following instruction is a load, add the constant
+ * index value to the address and switch the opcode to the
+ * unindexed form.
+ */
+
+ if (pptr[i+1]->op == oLDSXH)
+ {
+ pptr[i+1]->op = oLDSH;
+ pptr[i+1]->arg2 += val;
+ deletePcode (i);
+ nchanges++;
+ } /* end if */
+ else if (pptr[i+1]->op == oLASX)
+ {
+ pptr[i+1]->op = oLAS;
+ pptr[i+1]->arg2 += val;
+ deletePcode (i);
+ nchanges++;
+ } /* end else if */
+ else if (pptr[i+1]->op == oLDSXB)
+ {
+ pptr[i+1]->op = oLDSB;
+ pptr[i+1]->arg2 += val;
+ deletePcode (i);
+ nchanges++;
+ } /* end if */
+ else if (pptr[i+1]->op == oLDSXM)
+ {
+ pptr[i+1]->op = oLDSM;
+ pptr[i+1]->arg2 += val;
+ deletePcode (i);
+ nchanges++;
+ } /* end if */
+ else if (val < 256)
+ {
+ pptr[i]->op = oPUSHB;
+ pptr[i]->arg1 = val;
+ pptr[i]->arg2 = 0;
+ i++;
+ } /* end else if */
+ else i++;
+ break;
+
+ default :
+ i++;
+ break;
+ } /* end switch */
+ } /* end while */
+ return (nchanges);
+} /* end LoadOptimize */
+
+/**********************************************************************/
+sint16 StoreOptimize (void)
+{
+ uint16 val;
+ sint16 nchanges = 0;
+ register sint16 i;
+
+ TRACE(stderr, "[StoreOptimize]");
+
+ /* At least two pcodes are need to perform the following Store */
+ /* optimizations */
+
+ i = 0;
+ while (i < nops-1)
+ {
+ switch (pptr[i]->op)
+ {
+ /* Eliminate store followed by load */
+
+ case oSTSH :
+ if ((pptr[i+1]->op == oLDSH) &&
+ (pptr[i+1]->arg1 == pptr[i]->arg1) &&
+ (pptr[i+1]->arg2 == pptr[i]->arg2))
+ {
+ pptr[i+1]->op = oSTSH;
+ pptr[i]->op = oDUPH;
+ pptr[i]->arg1 = 0;
+ pptr[i]->arg2 = 0;
+ nchanges++;
+ i += 2;
+ } /* end if */
+ else i++;
+ break;
+
+ /* Convert stores indexed by a constant to unindexed stores */
+ case oPUSH :
+ /* Get the index value */
+
+ if (pptr[i]->op == oPUSH)
+ {
+ val = pptr[i]->arg2;
+ }
+ else
+ {
+ val = pptr[i]->arg1;
+ }
+
+ /* If the following instruction is a store, add the constant
+ * index value to the address and switch the opcode to the
+ * unindexed form.
+ */
+
+ if (i < nops-2)
+ {
+ if (pptr[i+2]->op == oSTSXH)
+ {
+ pptr[i+2]->op = oSTSH;
+ pptr[i+2]->arg2 += pptr[i]->arg2;
+ deletePcode (i);
+ nchanges++;
+ } /* end if */
+ else if (pptr[i+2]->op == oSTSXB)
+ {
+ pptr[i+2]->op = oSTSB;
+ pptr[i+2]->arg2 += pptr[i]->arg2;
+ deletePcode (i);
+ nchanges++;
+ } /* end if */
+ else i++;
+ } /* end if */
+ else i++;
+ break;
+
+ case oPUSHB :
+ if (i < nops-2)
+ {
+ if (pptr[i+2]->op == oSTSXB)
+ {
+ pptr[i+2]->op = oSTSB;
+ pptr[i+2]->arg2 += pptr[i]->arg2;
+ deletePcode (i);
+ nchanges++;
+ } /* end if */
+ else i++;
+ } /* end if */
+ else i++;
+ break;
+
+ default :
+ i++;
+ break;
+ } /* end switch */
+ } /* end while */
+
+ return (nchanges);
+
+} /* end StoreOptimize */
+
+/**********************************************************************/
+
diff --git a/misc/pascal/insn16/popt/plopt.h b/misc/pascal/insn16/popt/plopt.h new file mode 100644 index 000000000..b423006a7 --- /dev/null +++ b/misc/pascal/insn16/popt/plopt.h @@ -0,0 +1,44 @@ +/***************************************************************************
+ * plopt.h
+ * External Declarations associated with plopt.c
+ *
+ * Copyright (C) 2008 Gregory Nutt. All rights reserved.
+ * Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ * used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ***************************************************************************/
+
+#ifndef __PLOPT_H
+#define __PLOPT_H
+
+extern sint16 LoadOptimize ( void );
+extern sint16 StoreOptimize ( void );
+
+#endif __PLOPT_H
+
diff --git a/misc/pascal/insn16/popt/polocal.c b/misc/pascal/insn16/popt/polocal.c new file mode 100644 index 000000000..c2b2a5b67 --- /dev/null +++ b/misc/pascal/insn16/popt/polocal.c @@ -0,0 +1,300 @@ +/**********************************************************************
+ * polocal.c
+ * P-Code Local Optimizer
+ *
+ * Copyright (C) 2008 Gregory Nutt. All rights reserved.
+ * Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ * used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ **********************************************************************/
+
+/**********************************************************************
+ * Included Files
+ **********************************************************************/
+
+#include <stdio.h>
+
+#include "keywords.h"
+#include "podefs.h"
+#include "pinsn16.h"
+
+#include "pofflib.h"
+#include "paslib.h"
+#include "pinsn.h"
+#include "pcopt.h"
+#include "plopt.h"
+#include "pjopt.h"
+#include "polocal.h"
+
+/**********************************************************************
+ * Private Function Prototypes
+ **********************************************************************/
+
+static void initPTable (void);
+static void putPCodeFromTable (void);
+static void setupPointer (void);
+
+/**********************************************************************
+ * Global Variables
+ **********************************************************************/
+
+OPTYPE ptable [WINDOW]; /* Pcode Table */
+OPTYPE *pptr [WINDOW]; /* Valid Pcode Pointers */
+
+sint16 nops = 0; /* No. Valid Pcode Pointers */
+sint16 end_out = 0; /* 1 = oEND pcode has been output */
+
+/**********************************************************************
+ * Private Variables
+ **********************************************************************/
+
+static poffHandle_t myPoffHandle; /* Handle to POFF object */
+static poffProgHandle_t myPoffProgHandle;/* Handle to temporary POFF object */
+
+/**********************************************************************
+ * Global Functions
+ **********************************************************************/
+
+/***********************************************************************/
+
+void localOptimization(poffHandle_t poffHandle,
+ poffProgHandle_t poffProgHandle)
+{
+ sint16 nchanges;
+
+ TRACE(stderr, "[pass2]");
+
+ /* Save the handles for use by other, private functions */
+
+ myPoffHandle = poffHandle;
+ myPoffProgHandle = poffProgHandle;
+
+ /* Initialization */
+
+ initPTable();
+
+ /* Outer loop traverse the file op-code by op-code until the oEND P-Code
+ * has been output. NOTE: it is assumed throughout that oEND is the
+ * final P-Code in the program data section.
+ */
+
+ while (!(end_out))
+ {
+ /* The inner loop optimizes the buffered P-Codes until no further
+ * changes can be made. Then the outer loop will advance the buffer
+ * by one P-Code
+ */
+
+ do
+ {
+ nchanges = unaryOptimize ();
+ nchanges += binaryOptimize();
+ nchanges += BranchOptimize();
+ nchanges += LoadOptimize();
+ nchanges += StoreOptimize();
+ } while (nchanges);
+
+ putPCodeFromTable();
+ }
+}
+
+/***********************************************************************/
+
+void deletePcode(sint16 delIndex)
+{
+ TRACE(stderr, "[deletePcode]");
+
+ pptr[delIndex]->op = oNOP;
+ pptr[delIndex]->arg1 = 0;
+ pptr[delIndex]->arg2 = 0;
+ setupPointer();
+}
+
+/**********************************************************************/
+
+void deletePcodePair(sint16 delIndex1, sint16 delIndex2)
+{
+ TRACE(stderr, "[deletePcodePair]");
+
+ pptr[delIndex1]->op = oNOP;
+ pptr[delIndex1]->arg1 = 0;
+ pptr[delIndex1]->arg2 = 0;
+ pptr[delIndex2]->op = oNOP;
+ pptr[delIndex2]->arg1 = 0;
+ pptr[delIndex2]->arg2 = 0;
+ setupPointer();
+}
+
+/**********************************************************************
+ * Private Functions
+ **********************************************************************/
+
+/***********************************************************************/
+
+static void putPCodeFromTable(void)
+{
+ register sint16 i;
+
+ TRACE(stderr, "[putPCodeFromTable]");
+
+ /* Transfer all buffered P-Codes (except NOPs) to the optimized file */
+ do
+ {
+ if ((ptable[0].op != oNOP) && !(end_out))
+ {
+ (void)poffAddTmpProgByte(myPoffProgHandle, ptable[0].op);
+
+ if (ptable[0].op & o8)
+ (void)poffAddTmpProgByte(myPoffProgHandle, ptable[0].arg1);
+
+ if (ptable[0].op & o16)
+ {
+ (void)poffAddTmpProgByte(myPoffProgHandle,
+ (ptable[0].arg2 >> 8));
+ (void)poffAddTmpProgByte(myPoffProgHandle,
+ (ptable[0].arg2 & 0xff));
+ }
+
+ end_out =(ptable[0].op == oEND);
+ }
+
+ /* Move all P-Codes down one slot */
+
+ for (i = 1; i < WINDOW; i++)
+ {
+ ptable[i-1].op = ptable[i].op ;
+ ptable[i-1].arg1 = ptable[i].arg1;
+ ptable[i-1].arg2 = ptable[i].arg2;
+ }
+
+ /* Then fill the end slot with a new P-Code from the input file */
+
+ insn_GetOpCode(myPoffHandle, &ptable[WINDOW-1]);
+
+ } while (ptable[0].op == oNOP);
+ setupPointer();
+}
+
+/**********************************************************************/
+
+static void setupPointer(void)
+{
+ register sint16 pindex;
+
+ TRACE(stderr, "[setupPointer]");
+
+ for (pindex = 0; pindex < WINDOW; pindex++)
+ pptr[pindex] = (OPTYPE *) NULL;
+
+ nops = 0;
+ for (pindex = 0; pindex < WINDOW; pindex++)
+ {
+ switch (ptable[pindex].op)
+ {
+ /* Terminate list when a break from sequential logic is
+ * encountered
+ */
+
+ case oRET :
+ case oEND :
+ case oJMP :
+ case oLABEL :
+ case oPCAL :
+ return;
+
+ /* Terminate list when a condition break from sequential logic is
+ * encountered but include the conditional branch in the list
+ */
+
+ case oJEQUZ :
+ case oJNEQZ :
+ case oJLTZ :
+ case oJGTEZ :
+ case oJGTZ :
+ case oJLTEZ :
+ pptr[nops] = &ptable[pindex];
+ nops++;
+ return;
+
+ /* Skip over NOPs and comment class pcodes */
+
+ case oNOP :
+ case oLINE :
+ break;
+
+ /* Include all other pcodes in the optimization list and continue */
+
+ default :
+ pptr[nops] = &ptable[pindex];
+ nops++;
+ }
+ }
+}
+
+/**********************************************************************/
+
+static void initPTable(void)
+{
+ register sint16 i;
+
+ TRACE(stderr, "[intPTable]");
+
+ /* Skip over leading pcodes. NOTE: assumes executable begins after
+ * the first oLABEL pcode
+ */
+
+ do
+ {
+ insn_GetOpCode(myPoffHandle, &ptable[0]);
+
+ (void)poffAddTmpProgByte(myPoffProgHandle, ptable[0].op);
+
+ if (ptable[0].op & o8)
+ {
+ (void)poffAddTmpProgByte(myPoffProgHandle, ptable[0].arg1);
+ }
+
+ if (ptable[0].op & o16)
+ {
+ (void)poffAddTmpProgByte(myPoffProgHandle, (ptable[0].arg2 >> 8));
+ (void)poffAddTmpProgByte(myPoffProgHandle, (ptable[0].arg2 & 0xff));
+ } /* end if */
+ }
+ while ((ptable[0].op != oLABEL) && (ptable[0].op != oEND));
+
+ /* Fill the pcode window and setup pointers to working section */
+
+ for (i = 0; i < WINDOW; i++)
+ {
+ insn_GetOpCode(myPoffHandle, &ptable[i]);
+ }
+ setupPointer();
+}
+
+/***********************************************************************/
diff --git a/misc/pascal/insn16/popt/polocal.h b/misc/pascal/insn16/popt/polocal.h new file mode 100644 index 000000000..4bfb89b24 --- /dev/null +++ b/misc/pascal/insn16/popt/polocal.h @@ -0,0 +1,73 @@ +/***************************************************************************
+ * polocal.h
+ * External Declarations associated with polocal.c
+ *
+ * Copyright (C) 2008 Gregory Nutt. All rights reserved.
+ * Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ * used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ***************************************************************************/
+
+#ifndef __POLOCAL_H
+#define __POLOCAL_H
+
+/***************************************************************************
+* Included Files
+****************************************************************************/
+
+#include "keywords.h"
+#include "pdefs.h"
+#include "pofflib.h"
+
+/***************************************************************************
+* Definitions
+****************************************************************************/
+
+#define WINDOW 10 /* size of optimization window */
+
+/***************************************************************************
+* Global Function Prototypes
+****************************************************************************/
+
+extern void localOptimization(poffHandle_t poffHandle,
+ poffProgHandle_t poffProgHandle);
+extern void deletePcode (sint16 delIndex);
+extern void deletePcodePair (sint16 delIndex1, sint16 delIndex2);
+
+/***************************************************************************
+ * Global Variables
+ ****************************************************************************/
+
+extern OPTYPE ptable [WINDOW]; /* Pcode Table */
+extern OPTYPE *pptr [WINDOW]; /* Valid Pcode Pointers */
+
+extern sint16 nops; /* No. Valid Pcode Pointers */
+extern sint16 end_out; /* 1 = oEND pcode has been output */
+
+#endif /* __PLOCAL_H */
diff --git a/misc/pascal/insn16/popt/popt.c b/misc/pascal/insn16/popt/popt.c new file mode 100644 index 000000000..749710ada --- /dev/null +++ b/misc/pascal/insn16/popt/popt.c @@ -0,0 +1,288 @@ +/**********************************************************************
+ * popt.c
+ * P-Code Optimizer Main Logic
+ *
+ * Copyright (C) 2008 Gregory Nutt. All rights reserved.
+ * Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ * used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ **********************************************************************/
+
+/**********************************************************************
+ * Included Files
+ **********************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "keywords.h"
+#include "podefs.h"
+#include "paslib.h"
+#include "pofflib.h"
+
+#include "pinsn.h"
+#include "popt.h"
+#include "psopt.h"
+#include "polocal.h"
+#include "pfopt.h"
+
+/**********************************************************************
+ * Private Function Prototypes
+ **********************************************************************/
+
+static void readPoffFile (const char *filename);
+static void pass1 (void);
+static void pass2 (void);
+static void pass3 (void);
+static void writePoffFile (const char *filename);
+
+/**********************************************************************
+ * Global Variables
+ **********************************************************************/
+
+/**********************************************************************
+ * Private Variables
+ **********************************************************************/
+
+static poffHandle_t poffHandle; /* Handle to POFF object */
+
+/**********************************************************************
+ * Global Functions
+ **********************************************************************/
+
+/***********************************************************************/
+
+int main(int argc, char *argv[], char *envp[])
+{
+ TRACE(stderr, "[main]");
+
+ /* Check for existence of filename argument */
+
+ if (argc < 2)
+ {
+ printf("Filename Required\n");
+ exit (1);
+ } /* end if */
+
+ /* Read the POFF file into memory */
+
+ readPoffFile(argv[1]);
+
+ /* Performs pass1 optimization */
+
+ pass1();
+
+ /* Performs pass2 optimization */
+
+ insn_ResetOpCodeRead(poffHandle);
+ pass2();
+
+ /* Create final section offsets and relocation entries */
+
+ insn_ResetOpCodeRead(poffHandle);
+ pass3();
+
+ /* Write the POFF file */
+
+ writePoffFile(argv[1]);
+ return 0;
+
+} /* End main */
+
+/**********************************************************************
+ * Private Functions
+ **********************************************************************/
+
+/***********************************************************************/
+
+static void readPoffFile(const char *filename)
+{
+ char objname [FNAME_SIZE+1];
+ FILE *objFile;
+ uint16 errcode;
+
+ TRACE(stderr, "[readPoffFile]");
+
+ /* Open the pass1 POFF object file -- Use .o1 extension */
+
+ (void)extension(filename, "o1", objname, 1);
+ if (!(objFile = fopen(objname, "rb")))
+ {
+ printf("Error Opening %s\n", objname);
+ exit(1);
+ } /* end if */
+
+ /* Get a handle to a POFF input object */
+
+ poffHandle = poffCreateHandle();
+ if (!poffHandle)
+ {
+ printf("Could not get POFF handle\n");
+ exit(1);
+ } /* end if */
+
+ /* Read the POFF file into memory */
+
+ errcode = poffReadFile(poffHandle, objFile);
+ if (errcode != 0)
+ {
+ printf("Could not read POFF file, errcode=0x%02x\n", errcode);
+ exit(1);
+ }
+
+ /* Close the input file */
+
+ fclose(objFile);
+} /* end pass1 */
+
+/***********************************************************************/
+
+static void pass1(void)
+{
+ poffProgHandle_t poffProgHandle; /* Handle to temporary POFF object */
+
+ TRACE(stderr, "[pass1]");
+
+ /* Create a handle to a temporary object to store new POFF program
+ * data.
+ */
+
+ poffProgHandle = poffCreateProgHandle();
+ if (!poffProgHandle)
+ {
+ printf("Could not get POFF handle\n");
+ exit(1);
+ } /* end if */
+
+ /* Clean up garbage left from the wasteful string stack logic */
+
+ stringStackOptimize(poffHandle, poffProgHandle);
+
+ /* Replace the original program data with the new program data */
+
+ poffReplaceProgData(poffHandle, poffProgHandle);
+
+ /* Release the temporary POFF object */
+
+ poffDestroyProgHandle(poffProgHandle);
+} /* end pass1 */
+
+/***********************************************************************/
+
+static void pass2(void)
+{
+ poffProgHandle_t poffProgHandle; /* Handle to temporary POFF object */
+
+ TRACE(stderr, "[pass2]");
+
+ /* Create a handle to a temporary object to store new POFF program
+ * data.
+ */
+
+ poffProgHandle = poffCreateProgHandle();
+ if (!poffProgHandle)
+ {
+ printf("Could not get POFF handle\n");
+ exit(1);
+ } /* end if */
+
+ /* Perform Local Optimizatin Initialization */
+
+ localOptimization(poffHandle, poffProgHandle);
+
+ /* Replace the original program data with the new program data */
+
+ poffReplaceProgData(poffHandle, poffProgHandle);
+
+ /* Release the temporary POFF object */
+
+ poffDestroyProgHandle(poffProgHandle);
+} /* end pass2 */
+
+/***********************************************************************/
+
+static void pass3 (void)
+{
+ poffProgHandle_t poffProgHandle; /* Handle to temporary POFF object */
+ TRACE(stderr, "[pass3]");
+
+ /* Create a handle to a temporary object to store new POFF program
+ * data.
+ */
+
+ poffProgHandle = poffCreateProgHandle();
+ if (!poffProgHandle)
+ {
+ printf("Could not get POFF handle\n");
+ exit(1);
+ } /* end if */
+
+ /* Finalize program section, create relocation and line number
+ * sections.
+ */
+
+ optFinalize(poffHandle, poffProgHandle);
+
+ /* Release the temporary POFF object */
+
+ poffDestroyProgHandle(poffProgHandle);
+}
+
+/***********************************************************************/
+
+static void writePoffFile(const char *filename)
+{
+ char optname [FNAME_SIZE+1];
+ FILE *optFile;
+
+ TRACE(stderr, "[writePoffFile]");
+
+ /* Open optimized p-code file -- Use .o extension */
+
+ (void)extension(filename, "o", optname, 1);
+ if (!(optFile = fopen(optname, "wb")))
+ {
+ printf("Error Opening %s\n", optname);
+ exit(1);
+ } /* end if */
+
+ /* Then write the new POFF file */
+
+ poffWriteFile(poffHandle, optFile);
+
+ /* Destroy the POFF object */
+
+ poffDestroyHandle(poffHandle);
+
+ /* Close the files used on writePoffFile */
+
+ (void)fclose(optFile);
+} /* end writePoffFile */
+
+/***********************************************************************/
diff --git a/misc/pascal/insn16/popt/popt.h b/misc/pascal/insn16/popt/popt.h new file mode 100644 index 000000000..e5825466a --- /dev/null +++ b/misc/pascal/insn16/popt/popt.h @@ -0,0 +1,52 @@ +/***************************************************************************
+ * popt.h
+ * External Declarations associated with popt.c
+ *
+ * Copyright (C) 2008 Gregory Nutt. All rights reserved.
+ * Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ * used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ***************************************************************************/
+
+#ifndef __POPT_H
+#define __POPT_H
+
+/***************************************************************************
+* Included Files
+****************************************************************************/
+
+/***************************************************************************
+* Global Function Prototypes
+****************************************************************************/
+
+/***************************************************************************
+ * Global Variables
+ ****************************************************************************/
+
+#endif /* __POPT_H */
diff --git a/misc/pascal/insn16/popt/psopt.c b/misc/pascal/insn16/popt/psopt.c new file mode 100644 index 000000000..8d36ac0aa --- /dev/null +++ b/misc/pascal/insn16/popt/psopt.c @@ -0,0 +1,386 @@ +/********************************************************************** + * psopt.c + * String Stack Optimizaitons + * + * Copyright (C) 2008 Gregory Nutt. All rights reserved. + * Author: Gregory Nutt <spudmonkey@racsa.co.cr> + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * 3. Neither the name NuttX nor the names of its contributors may be + * used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + **********************************************************************/ + +/* The statement generation logic generates a PUSHS and POPS around + * every statement. These instructions save and restore the string + * stack pointer registers. However, only some statements actually + * modify the string stack. So the first major step in the optimatization + * process is to retain only PUSHS and POPS statements that are + * actually required. + */ + +/********************************************************************** + * Included Files + **********************************************************************/ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "keywords.h" +#include "pdefs.h" +#include "pedefs.h" +#include "pinsn16.h" +#include "pxdefs.h" + +#include "popt.h" +#include "psopt.h" + +/********************************************************************** + * Definitions + **********************************************************************/ + +#define PBUFFER_SIZE 1024 +#define NPBUFFERS 8 + +/********************************************************************** + * Private Data + **********************************************************************/ + +static ubyte *pbuffer[NPBUFFERS]; +static int nbytes_in_pbuffer[NPBUFFERS]; +static int current_level = -1; +static int inch; + +/********************************************************************** + * Private Function Prototypes + **********************************************************************/ + +static inline void putbuf(int c, poffProgHandle_t poffProgHandle); +static inline void flushc(int c, poffProgHandle_t poffProgHandle); +static inline void flushbuf(poffProgHandle_t poffProgHandle); +static void dopush(poffHandle_t poffHandle, poffProgHandle_t poffProgHandle); +static void dopop(poffHandle_t poffHandle, poffProgHandle_t poffProgHandle); + +/********************************************************************** + * Private Inline Functions + **********************************************************************/ + +static inline void putbuf(int c, poffProgHandle_t poffProgHandle) +{ + int dlvl = current_level; + + if (dlvl < 0) + { + /* No PUSHS encountered. Write byte directly to output */ + + poffAddTmpProgByte(poffProgHandle, (ubyte)c); + } + else + { + /* PUSHS encountered. Write byte into buffer associated with + * nesting level. + */ + + int idx = nbytes_in_pbuffer[dlvl]; + ubyte *dest = pbuffer[dlvl] + idx; + *dest = c; + nbytes_in_pbuffer[dlvl] = idx + 1; + } +} + +static inline void flushc(int c, poffProgHandle_t poffProgHandle) +{ + if (current_level > 0) + { + /* Nested PUSHS encountered. Write byte into buffer associated + * with the previous nesting level. + */ + + int dlvl = current_level - 1; + int idx = nbytes_in_pbuffer[dlvl]; + ubyte *dest = pbuffer[dlvl] + idx; + *dest = c; + nbytes_in_pbuffer[dlvl] = idx + 1; + } + else + { + /* Only one PUSHS encountered. Write directly to the output + * buffer + */ + + poffAddTmpProgByte(poffProgHandle, (ubyte)c); + } +} + +static inline void flushbuf(poffProgHandle_t poffProgHandle) +{ + uint16 errCode; + int slvl = current_level; + + if (nbytes_in_pbuffer[slvl] > 0) + { + if (current_level > 0) + { + /* Nested PUSHS encountered. Flush buffer into buffer associated + * with the previous nesting level. + */ + + int dlvl = slvl - 1; + ubyte *src = pbuffer[slvl]; + ubyte *dest = pbuffer[dlvl] + nbytes_in_pbuffer[dlvl]; + + memcpy(dest, src, nbytes_in_pbuffer[slvl]); + nbytes_in_pbuffer[dlvl] += nbytes_in_pbuffer[slvl]; + } + else + { + /* Only one PUSHS encountered. Flush directly to the output + * buffer + */ + + errCode = poffWriteTmpProgBytes(pbuffer[0], nbytes_in_pbuffer[0], + poffProgHandle); + + if (errCode != eNOERROR) + { + printf("Error writing to file: %d\n", errCode); + exit(1); + } + } + } + nbytes_in_pbuffer[slvl] = 0; +} + +/********************************************************************** + * Private Functions + **********************************************************************/ + +static void dopush(poffHandle_t poffHandle, poffProgHandle_t poffProgHandle) +{ + int opcode; + + while (inch != EOF) + { + /* Search for a PUSHS opcode */ + + if (inch != oPUSHS) + { + /* Its not PUSHS, just echo to the output file/buffer */ + + putbuf(inch, poffProgHandle); + + /* Get the next byte from the input stream */ + + opcode = inch; + inch = poffGetProgByte(poffHandle); + + /* Check for an 8-bit argument */ + + if ((opcode & o8) != 0) + { + /* Echo the 8-bit argument */ + + putbuf(inch, poffProgHandle); + inch = poffGetProgByte(poffHandle); + } + + /* Check for a 16-bit argument */ + + if ((opcode & o16) != 0) + { + /* Echo the 16-bit argument */ + + putbuf(inch, poffProgHandle); + inch = poffGetProgByte(poffHandle); + putbuf(inch, poffProgHandle); + inch = poffGetProgByte(poffHandle); + } + } + else + { + /* We have found PUSHS. No search for the next occurrence + * of either and instruction that increments the string + * stack or for the matching POPS + */ + + current_level++; + dopop(poffHandle, poffProgHandle); + current_level--; + } + } +} + +static void dopop(poffHandle_t poffHandle, poffProgHandle_t poffProgHandle) +{ + int opcode; + int arg16; + int arg16a; + int arg16b; + + /* We have found PUSHS. No search for the next occurrence + * of either and instruction that increments the string + * stack or for the matching POPS + */ + + /* Skip over the PUSHS for now */ + + inch = poffGetProgByte(poffHandle); + + while (inch != EOF) + { + /* Did we encounter another PUSHS? */ + + if (inch == oPUSHS) + { + /* Yes... recurse to handle it */ + + current_level++; + dopop(poffHandle, poffProgHandle); + current_level--; + } + + else if (inch == oPOPS) + { + /* Flush the buffered data without the PUSHS */ + + flushbuf(poffProgHandle); + + /* And discard the matching POPS */ + + inch = poffGetProgByte(poffHandle); + break; + } + else if (inch == oLIB) + { + /* Get the 16-bit argument */ + + putbuf(inch, poffProgHandle); + arg16a = poffGetProgByte(poffHandle); + putbuf(arg16a, poffProgHandle); + arg16b = poffGetProgByte(poffHandle); + putbuf(arg16b, poffProgHandle); + arg16 = (arg16a << 8) | arg16b; + inch = poffGetProgByte(poffHandle); + + /* Is it LIB MKSTK? MKSTKSTR? or MKSTKC? */ + + if ((arg16 == lbMKSTK) || + (arg16 == lbMKSTKSTR) || + (arg16 == lbMKSTKC)) + { + /* Flush the buffered data with the PUSHS */ + + flushc(oPUSHS, poffProgHandle); + flushbuf(poffProgHandle); + + /* And break out of the loop to search for + * the next PUSHS + */ + + break; + } + } + else + { + /* Something else. Put it in the buffer */ + + putbuf(inch, poffProgHandle); + + /* Get the next byte from the input stream */ + + opcode = inch; + inch = poffGetProgByte(poffHandle); + + /* Check for an 8-bit argument */ + + if ((opcode & o8) != 0) + { + /* Buffer the 8-bit argument */ + + putbuf(inch, poffProgHandle); + inch = poffGetProgByte(poffHandle); + } + + /* Check for a 16-bit argument */ + + if ((opcode & o16) != 0) + { + /* Buffer the 16-bit argument */ + + putbuf(inch, poffProgHandle); + inch = poffGetProgByte(poffHandle); + putbuf(inch, poffProgHandle); + inch = poffGetProgByte(poffHandle); + } + } + } +} + +/********************************************************************** + * Global Functions + **********************************************************************/ + +void stringStackOptimize(poffHandle_t poffHandle, + poffProgHandle_t poffProgHandle) +{ + int i; + + /* Allocate an array of buffers to hold pcode data */ + + for (i = 0; i < NPBUFFERS; i++) + { + pbuffer[i] = (ubyte*)malloc(PBUFFER_SIZE); + if (pbuffer[i] == NULL) + { + printf("Failed to allocate pcode buffer\n"); + exit(1); + } + nbytes_in_pbuffer[i] = 0; + } + + /* Prime the search logic */ + + inch = poffGetProgByte(poffHandle); + current_level = -1; + + /* And parse the input file to the output file, removing unnecessary string + * stack operations. + */ + + dopush(poffHandle, poffProgHandle); + + /* Release the buffers */ + + for (i = 0; i < NPBUFFERS; i++) + { + free(pbuffer[i]); + pbuffer[i] = NULL; + nbytes_in_pbuffer[i] = 0; + } +} + +/**********************************************************************/ diff --git a/misc/pascal/insn16/popt/psopt.h b/misc/pascal/insn16/popt/psopt.h new file mode 100644 index 000000000..c174aac8e --- /dev/null +++ b/misc/pascal/insn16/popt/psopt.h @@ -0,0 +1,54 @@ +/***************************************************************************
+ * psopt.h
+ * External Declarations associated with psopt.c
+ *
+ * Copyright (C) 2008 Gregory Nutt. All rights reserved.
+ * Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ * used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ***************************************************************************/
+
+#ifndef __PSOPT_H
+#define __PSOPT_H
+
+/***************************************************************************
+ * Included Files
+ ***************************************************************************/
+
+#include "pofflib.h"
+
+/***************************************************************************
+ * Global Function Prototypes
+ ***************************************************************************/
+
+extern void stringStackOptimize(poffHandle_t poffHandle,
+ poffProgHandle_t poffProgHandle);
+
+#endif /* __PSOPT_H */
+
|