sdcc-3.9.0 fork implementing GNU assembler syntax

This fork aims to provide better support for stm8-binutils

1 files changed, 7842 insertions, 0 deletions

diff --git a/src/pic14/gen.c b/src/pic14/gen.c
new file mode 100644
index 0000000..7dd7548
--- /dev/null
+++ b/src/pic14/gen.c
@@ -0,0 +1,7842 @@
+/*-------------------------------------------------------------------------
+  gen.c - source file for code generation for pic
+
+  Copyright (C) 1998, Sandeep Dutta . sandeep.dutta@usa.net
+  Copyright (C) 1999, Jean-Louis VERN.jlvern@writeme.com
+  Bug Fixes  -  Wojciech Stryjewski  wstryj1@tiger.lsu.edu (1999 v2.1.9a)
+  PIC port:
+  Copyright (C) 2000, Scott Dattalo scott@dattalo.com
+  Copyright (C) 2005, Raphael Neider <rneider AT web.de>
+
+  This program is free software; you can redistribute it and/or modify it
+  under the terms of the GNU General Public License as published by the
+  Free Software Foundation; either version 2, or (at your option) any
+  later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+-------------------------------------------------------------------------*/
+/*
+  Notes:
+  000123 mlh  Moved aopLiteral to SDCCglue.c to help the split
+              Made everything static
+*/
+
+/*
+ * This is the down and dirty file with all kinds of
+ * kludgy & hacky stuff. This is what it is all about
+ * CODE GENERATION for a specific MCU . some of the
+ * routines may be reusable, will have to see.
+ */
+
+#include "device.h"
+#include "gen.h"
+#include "glue.h"
+#include "dbuf_string.h"
+
+/*
+ * Imports
+ */
+extern struct dbuf_s *codeOutBuf;
+extern set *externs;
+
+static PIC_device *pic = NULL;
+
+static pCodeOp *popGetImmd (const char *name, unsigned int offset, int index, int is_func);
+static pCodeOp *popRegFromString (const char *str, int size, int offset);
+static int aop_isLitLike (asmop * aop);
+static void genCritical (iCode * ic);
+static void genEndCritical (iCode * ic);
+
+/* The PIC port(s) need not differentiate between POINTER and FPOINTER. */
+#define PIC_IS_DATA_PTR(x)  (IS_DATA_PTR(x) || IS_FARPTR(x))
+
+/*
+ * max_key keeps track of the largest label number used in
+ * a function. This is then used to adjust the label offset
+ * for the next function.
+ */
+static int max_key = 0;
+static int labelOffset = 0;
+static int GpseudoStkPtr = 0;
+static int pic14_inISR = 0;
+
+static char *zero = "0x00";
+static char *one = "0x01";
+static char *spname = "sp";
+
+unsigned fReturnSizePic = 4;    /* shared with ralloc.c */
+static char *fReturnpic14[] = { "temp1", "temp2", "temp3", "temp4" };
+
+static char **fReturn = fReturnpic14;
+
+static struct
+{
+  short accInUse;
+  short nRegsSaved;
+  set *sendSet;
+} _G;
+
+/*
+ * Resolved ifx structure. This structure stores information
+ * about an iCode ifx that makes it easier to generate code.
+ */
+typedef struct resolvedIfx
+{
+  symbol *lbl;                  /* pointer to a label */
+  int condition;                /* true or false ifx */
+  int generated;                /* set true when the code associated with the ifx
+                                 * is generated */
+} resolvedIfx;
+
+static pBlock *pb;
+
+/*-----------------------------------------------------------------*/
+/*  my_powof2(n) - If `n' is an integer power of 2, then the       */
+/*                 exponent of 2 is returned, otherwise -1 is      */
+/*                 returned.                                       */
+/* note that this is similar to the function `powof2' in SDCCsymt  */
+/* if(n == 2^y)                                                    */
+/*   return y;                                                     */
+/* return -1;                                                      */
+/*-----------------------------------------------------------------*/
+static int
+my_powof2 (unsigned long num)
+{
+  if (num)
+    {
+      if ((num & (num - 1)) == 0)
+        {
+          int nshifts = -1;
+          while (num)
+            {
+              num >>= 1;
+              nshifts++;
+            }
+          return nshifts;
+        }
+    }
+
+  return -1;
+}
+
+void
+DEBUGpic14_AopType (int line_no, operand * left, operand * right, operand * result)
+{
+
+  DEBUGpic14_emitcode ("; ", "line = %d result %s=%s, size=%d, left %s=%s, size=%d, right %s=%s, size=%d",
+                       line_no,
+                       ((result) ? AopType (AOP_TYPE (result)) : "-"),
+                       ((result) ? aopGet (AOP (result), 0, TRUE, FALSE) : "-"),
+                       ((result) ? AOP_SIZE (result) : 0),
+                       ((left) ? AopType (AOP_TYPE (left)) : "-"),
+                       ((left) ? aopGet (AOP (left), 0, TRUE, FALSE) : "-"),
+                       ((left) ? AOP_SIZE (left) : 0),
+                       ((right) ? AopType (AOP_TYPE (right)) : "-"),
+                       ((right) ? aopGet (AOP (right), 0, FALSE, FALSE) : "-"), ((right) ? AOP_SIZE (right) : 0));
+
+}
+
+static void
+DEBUGpic14_AopTypeSign (int line_no, operand * left, operand * right, operand * result)
+{
+
+  DEBUGpic14_emitcode ("; ", "line = %d, signs: result %s=%c, left %s=%c, right %s=%c",
+                       line_no,
+                       ((result) ? AopType (AOP_TYPE (result)) : "-"),
+                       ((result) ? (SPEC_USIGN (operandType (result)) ? 'u' : 's') : '-'),
+                         ((left) ? AopType (AOP_TYPE (left)) : "-"),
+                         ((left) ? (SPEC_USIGN (operandType (left)) ? 'u' : 's') : '-'),
+                         ((right) ? AopType (AOP_TYPE (right)) : "-"),
+                         ((right) ? (SPEC_USIGN (operandType (right)) ? 'u' : 's') : '-'));
+
+}
+
+void
+DEBUGpic14_emitcode (const char *inst, const char *fmt, ...)
+{
+  va_list ap;
+
+  if (!debug_verbose && !options.debug)
+    return;
+
+  va_start (ap, fmt);
+  va_emitcode (inst, fmt, ap);
+  va_end (ap);
+
+  addpCode2pBlock (pb, newpCodeCharP (genLine.lineCurr->line));
+}
+
+void
+emitpComment (const char *fmt, ...)
+{
+  va_list ap;
+  struct dbuf_s dbuf;
+  const char *line;
+
+  dbuf_init (&dbuf, INITIAL_INLINEASM);
+
+  dbuf_append_char (&dbuf, ';');
+  va_start (ap, fmt);
+  dbuf_vprintf (&dbuf, fmt, ap);
+  va_end (ap);
+
+  line = dbuf_detach_c_str (&dbuf);
+  emit_raw (line);
+  dbuf_free (line);
+
+  addpCode2pBlock (pb, newpCodeCharP (genLine.lineCurr->line));
+}
+
+void
+emitpLabel (int key)
+{
+  addpCode2pBlock (pb, newpCodeLabel (NULL, labelKey2num (key + labelOffset)));
+}
+
+/* gen.h defines a macro emitpcode that should be used to call emitpcode
+ * as this allows for easy debugging (ever asked the question: where was
+ * this instruction geenrated? Here is the answer... */
+void
+emitpcode_real (PIC_OPCODE poc, pCodeOp * pcop)
+{
+  if (pcop)
+    addpCode2pBlock (pb, newpCode (poc, pcop));
+  else
+    {
+      static int has_warned = FALSE;
+
+      DEBUGpic14_emitcode (";", "%s  ignoring NULL pcop", __FUNCTION__);
+      if (!has_warned)
+        {
+          has_warned = TRUE;
+          fprintf (stderr, "WARNING: encountered NULL pcop--this is probably a compiler bug...\n");
+        }
+    }
+}
+
+static void
+emitpcodeNULLop (PIC_OPCODE poc)
+{
+  addpCode2pBlock (pb, newpCode (poc, NULL));
+}
+
+/*-----------------------------------------------------------------*/
+/* pic14_emitcode - writes the code into a file : for now it is simple    */
+/*-----------------------------------------------------------------*/
+void
+pic14_emitcode (const char *inst, const char *fmt, ...)
+{
+  va_list ap;
+
+  va_start (ap, fmt);
+  va_emitcode (inst, fmt, ap);
+  va_end (ap);
+
+  if (debug_verbose)
+    addpCode2pBlock (pb, newpCodeCharP (genLine.lineCurr->line));
+}
+
+/*-----------------------------------------------------------------*/
+/* pic14_emitDebuggerSymbol - associate the current code location  */
+/*   with a debugger symbol                                        */
+/*-----------------------------------------------------------------*/
+void
+pic14_emitDebuggerSymbol (const char *debugSym)
+{
+  genLine.lineElement.isDebug = TRUE;
+  pic14_emitcode ("", ";%s ==.", debugSym);
+  genLine.lineElement.isDebug = FALSE;
+}
+
+/*-----------------------------------------------------------------*/
+/* newAsmop - creates a new asmOp                                  */
+/*-----------------------------------------------------------------*/
+static asmop *
+newAsmop (short type)
+{
+  asmop *aop;
+
+  aop = Safe_alloc(sizeof(asmop));
+  aop->type = type;
+  return aop;
+}
+
+/*-----------------------------------------------------------------*/
+/* resolveIfx - converts an iCode ifx into a form more useful for  */
+/*              generating code                                    */
+/*-----------------------------------------------------------------*/
+static void
+resolveIfx (resolvedIfx * resIfx, iCode * ifx)
+{
+  if (!resIfx)
+    return;
+
+  //  DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
+
+  resIfx->condition = TRUE;     /* assume that the ifx is true */
+  resIfx->generated = FALSE;    /* indicate that the ifx has not been used */
+
+  if (!ifx)
+    {
+      resIfx->lbl = NULL;       /* this is wrong: newiTempLabel(NULL);  / * oops, there is no ifx. so create a label */
+    }
+  else
+    {
+      if (IC_TRUE (ifx))
+        {
+          resIfx->lbl = IC_TRUE (ifx);
+        }
+      else
+        {
+          resIfx->lbl = IC_FALSE (ifx);
+          resIfx->condition = FALSE;
+        }
+    }
+
+  //  DEBUGpic14_emitcode("; ***","%s lbl->key=%d, (lab offset=%d)",__FUNCTION__,resIfx->lbl->key,labelOffset);
+
+}
+
+/*-----------------------------------------------------------------*/
+/* aopForSym - for a true symbol                                   */
+/*-----------------------------------------------------------------*/
+static asmop *
+aopForSym (iCode * ic, symbol * sym, bool result)
+{
+  asmop *aop;
+  memmap *space = SPEC_OCLS (sym->etype);
+
+  DEBUGpic14_emitcode ("; ***", "%s %d", __FUNCTION__, __LINE__);
+  /* if already has one */
+  if (sym->aop)
+    return sym->aop;
+
+  //DEBUGpic14_emitcode(";","%d",__LINE__);
+  /* if it is in direct space */
+  if (IN_DIRSPACE (space))
+    {
+      sym->aop = aop = newAsmop (AOP_DIR);
+      aop->aopu.aop_dir = sym->rname;
+      aop->size = getSize (sym->type);
+      DEBUGpic14_emitcode (";", "%d sym->rname = %s, size = %d", __LINE__, sym->rname, aop->size);
+      return aop;
+    }
+
+  /* special case for a function */
+  if (IS_FUNC (sym->type))
+    {
+
+      sym->aop = aop = newAsmop (AOP_PCODE);
+      aop->aopu.pcop = popGetImmd (sym->rname, 0, 0, 1);
+      PCOI (aop->aopu.pcop)->_const = IN_CODESPACE (space);
+      PCOI (aop->aopu.pcop)->_function = TRUE;
+      PCOI (aop->aopu.pcop)->index = 0;
+      aop->size = FARPTRSIZE;
+      DEBUGpic14_emitcode (";", "%d size = %d, name =%s", __LINE__, aop->size, sym->rname);
+      return aop;
+    }
+
+  if (IS_ARRAY (sym->type))
+    {
+      sym->aop = aop = newAsmop (AOP_PCODE);
+      aop->aopu.pcop = popGetImmd (sym->rname, 0, 0, 1);
+      PCOI (aop->aopu.pcop)->_const = IN_CODESPACE (space);
+      PCOI (aop->aopu.pcop)->_function = FALSE;
+      PCOI (aop->aopu.pcop)->index = 0;
+      aop->size = getSize (sym->etype) * DCL_ELEM (sym->type);
+
+      DEBUGpic14_emitcode (";", "%d size = %d, name =%s", __LINE__, aop->size, sym->rname);
+      return aop;
+    }
+
+  /* only remaining is far space */
+  /* in which case DPTR gets the address */
+  sym->aop = aop = newAsmop (AOP_PCODE);
+
+  aop->aopu.pcop = popGetImmd (sym->rname, 0, 0, 0);
+  PCOI (aop->aopu.pcop)->_const = IN_CODESPACE (space);
+  PCOI (aop->aopu.pcop)->index = 0;
+
+  DEBUGpic14_emitcode (";", "%d: rname %s, val %d, const = %d", __LINE__, sym->rname, 0, PCOI (aop->aopu.pcop)->_const);
+
+  allocDirReg (IC_LEFT (ic));
+
+  aop->size = FARPTRSIZE;
+
+  /* if it is in code space */
+  if (IN_CODESPACE (space))
+    aop->code = TRUE;
+
+  return aop;
+}
+
+/*-----------------------------------------------------------------*/
+/* aopForRemat - rematerialzes an object                           */
+/*-----------------------------------------------------------------*/
+static asmop *
+aopForRemat (operand * op)      // x symbol *sym)
+{
+  symbol *sym = OP_SYMBOL (op);
+  iCode *ic = NULL;
+  asmop *aop = newAsmop (AOP_PCODE);
+  int val = 0;
+
+  ic = sym->rematiCode;
+
+  DEBUGpic14_emitcode (";", "%s %d", __FUNCTION__, __LINE__);
+  if (IS_OP_POINTER (op))
+    {
+      DEBUGpic14_emitcode (";", "%s %d IS_OP_POINTER", __FUNCTION__, __LINE__);
+    }
+  for (;;)
+    {
+      if (ic->op == '+')
+        {
+          val += (int) operandLitValue (IC_RIGHT (ic));
+        }
+      else if (ic->op == '-')
+        {
+          val -= (int) operandLitValue (IC_RIGHT (ic));
+        }
+      else
+        break;
+
+      ic = OP_SYMBOL (IC_LEFT (ic))->rematiCode;
+    }
+
+  aop->aopu.pcop = popGetImmd (OP_SYMBOL (IC_LEFT (ic))->rname, 0, val, 0);
+  PCOI (aop->aopu.pcop)->_const = IS_PTR_CONST (operandType (op));
+  PCOI (aop->aopu.pcop)->index = val;
+
+  DEBUGpic14_emitcode (";", "%d: rname %s, val %d, const = %d",
+                       __LINE__, OP_SYMBOL (IC_LEFT (ic))->rname, val, IS_PTR_CONST (operandType (op)));
+
+  //  DEBUGpic14_emitcode(";","aop type  %s",AopType(AOP_TYPE(IC_LEFT(ic))));
+
+  allocDirReg (IC_LEFT (ic));
+
+  return aop;
+}
+
+static int
+aopIdx (asmop * aop, int offset)
+{
+  if (!aop)
+    return -1;
+
+  if (aop->type != AOP_REG)
+    return -2;
+
+  return aop->aopu.aop_reg[offset]->rIdx;
+
+}
+
+/*-----------------------------------------------------------------*/
+/* regsInCommon - two operands have some registers in common       */
+/*-----------------------------------------------------------------*/
+static bool
+regsInCommon (operand * op1, operand * op2)
+{
+  symbol *sym1, *sym2;
+  int i;
+
+  /* if they have registers in common */
+  if (!IS_SYMOP (op1) || !IS_SYMOP (op2))
+    return FALSE;
+
+  sym1 = OP_SYMBOL (op1);
+  sym2 = OP_SYMBOL (op2);
+
+  if (sym1->nRegs == 0 || sym2->nRegs == 0)
+    return FALSE;
+
+  for (i = 0; i < sym1->nRegs; i++)
+    {
+      int j;
+      if (!sym1->regs[i])
+        continue;
+
+      for (j = 0; j < sym2->nRegs; j++)
+        {
+          if (!sym2->regs[j])
+            continue;
+
+          if (sym2->regs[j] == sym1->regs[i])
+            return TRUE;
+        }
+    }
+
+  return FALSE;
+}
+
+/*-----------------------------------------------------------------*/
+/* operandsEqu - equivalent                                        */
+/*-----------------------------------------------------------------*/
+static bool
+operandsEqu (operand * op1, operand * op2)
+{
+  symbol *sym1, *sym2;
+
+  /* if they not symbols */
+  if (!IS_SYMOP (op1) || !IS_SYMOP (op2))
+    return FALSE;
+
+  sym1 = OP_SYMBOL (op1);
+  sym2 = OP_SYMBOL (op2);
+
+  /* if both are itemps & one is spilt
+     and the other is not then false */
+  if (IS_ITEMP (op1) && IS_ITEMP (op2) && sym1->isspilt != sym2->isspilt)
+    return FALSE;
+
+  /* if they are the same */
+  if (sym1 == sym2)
+    return TRUE;
+
+  if (sym1->rname[0] && sym2->rname[0] && strcmp (sym1->rname, sym2->rname) == 0)
+    return TRUE;
+
+
+  /* if left is a tmp & right is not */
+  if (IS_ITEMP (op1) && !IS_ITEMP (op2) && sym1->isspilt && (sym1->usl.spillLoc == sym2))
+    return TRUE;
+
+  if (IS_ITEMP (op2) && !IS_ITEMP (op1) && sym2->isspilt && sym1->level > 0 && (sym2->usl.spillLoc == sym1))
+    return TRUE;
+
+  return FALSE;
+}
+
+/*-----------------------------------------------------------------*/
+/* pic14_sameRegs - two asmops have the same registers             */
+/*-----------------------------------------------------------------*/
+bool
+pic14_sameRegs (asmop * aop1, asmop * aop2)
+{
+  int i;
+
+  if (aop1 == aop2)
+    return TRUE;
+
+  if (aop1->type != AOP_REG || aop2->type != AOP_REG)
+    return FALSE;
+
+  if (aop1->size != aop2->size)
+    return FALSE;
+
+  for (i = 0; i < aop1->size; i++)
+    if (aop1->aopu.aop_reg[i] != aop2->aopu.aop_reg[i])
+      return FALSE;
+
+  return TRUE;
+}
+
+/*-----------------------------------------------------------------*/
+/* aopOp - allocates an asmop for an operand  :                    */
+/*-----------------------------------------------------------------*/
+void
+aopOp (operand * op, iCode * ic, bool result)
+{
+  asmop *aop;
+  symbol *sym;
+  int i;
+
+  if (!op)
+    return;
+
+  /* if this a literal */
+  if (IS_OP_LITERAL (op))
+    {
+      op->aop = aop = newAsmop (AOP_LIT);
+      aop->aopu.aop_lit = OP_VALUE (op);
+      aop->size = getSize (operandType (op));
+      return;
+    }
+
+  {
+    sym_link *type = operandType (op);
+    if (IS_PTR_CONST (type))
+      DEBUGpic14_emitcode (";", "%d aop type is const pointer", __LINE__);
+  }
+
+  /* if already has a asmop then continue */
+  if (op->aop)
+    return;
+
+  /* if the underlying symbol has a aop */
+  if (IS_SYMOP (op) && OP_SYMBOL (op)->aop)
+    {
+      DEBUGpic14_emitcode (";", "%d", __LINE__);
+      op->aop = OP_SYMBOL (op)->aop;
+      return;
+    }
+
+  /* if this is a true symbol */
+  if (IS_TRUE_SYMOP (op))
+    {
+      //DEBUGpic14_emitcode(";","%d - true symop",__LINE__);
+      op->aop = aopForSym (ic, OP_SYMBOL (op), result);
+      return;
+    }
+
+  /* this is a temporary : this has
+     only four choices :
+     a) register
+     b) spillocation
+     c) rematerialize
+     d) conditional
+     e) can be a return use only */
+
+  sym = OP_SYMBOL (op);
+
+
+  /* if the type is a conditional */
+  if (sym->regType == REG_CND)
+    {
+      aop = op->aop = sym->aop = newAsmop (AOP_CRY);
+      aop->size = 0;
+      return;
+    }
+
+  /* if it is spilt then two situations
+     a) is rematerialize
+     b) has a spill location */
+  if (sym->isspilt || sym->nRegs == 0)
+    {
+
+      DEBUGpic14_emitcode (";", "%d", __LINE__);
+      /* rematerialize it NOW */
+      if (sym->remat)
+        {
+
+          sym->aop = op->aop = aop = aopForRemat (op);
+          aop->size = getSize (sym->type);
+          //DEBUGpic14_emitcode(";"," %d: size %d, %s\n",__LINE__,aop->size,aop->aopu.aop_immd);
+          return;
+        }
+
+      if (sym->ruonly)
+        {
+          if (sym->isptr)       // && sym->uptr
+            {
+              aop = op->aop = sym->aop = newAsmop (AOP_PCODE);
+              aop->aopu.pcop = newpCodeOp (NULL, PO_GPR_POINTER);       //popCopyReg(&pc_fsr);
+
+              //PCOI(aop->aopu.pcop)->_const = 0;
+              //PCOI(aop->aopu.pcop)->index = 0;
+              /*
+                 DEBUGpic14_emitcode(";","%d: rname %s, val %d, const = %d",
+                 __LINE__,sym->rname, 0, PCOI(aop->aopu.pcop)->_const);
+               */
+              //allocDirReg (IC_LEFT(ic));
+
+              aop->size = getSize (sym->type);
+              DEBUGpic14_emitcode (";", "%d", __LINE__);
+              return;
+
+            }
+          else
+            {
+
+              unsigned i;
+
+              aop = op->aop = sym->aop = newAsmop (AOP_STR);
+              aop->size = getSize (sym->type);
+              for (i = 0; i < fReturnSizePic; i++)
+                aop->aopu.aop_str[i] = fReturn[i];
+
+              DEBUGpic14_emitcode (";", "%d", __LINE__);
+              return;
+            }
+        }
+
+      /* else spill location  */
+      if (sym->isspilt && sym->usl.spillLoc)
+        {
+          asmop *oldAsmOp = NULL;
+
+          if (getSize (sym->type) != getSize (sym->usl.spillLoc->type))
+            {
+              /* force a new aop if sizes differ */
+              oldAsmOp = sym->usl.spillLoc->aop;
+              sym->usl.spillLoc->aop = NULL;
+            }
+          DEBUGpic14_emitcode (";", "%s %d %s sym->rname = %s, offset %d",
+                               __FUNCTION__, __LINE__, sym->usl.spillLoc->rname, sym->rname, sym->usl.spillLoc->offset);
+
+          sym->aop = op->aop = aop = newAsmop (AOP_PCODE);
+          if (getSize (sym->type) != getSize (sym->usl.spillLoc->type))
+            {
+              /* Don't reuse the new aop, go with the last one */
+              sym->usl.spillLoc->aop = oldAsmOp;
+            }
+          //aop->aopu.pcop = popGetImmd(sym->usl.spillLoc->rname,0,sym->usl.spillLoc->offset);
+          aop->aopu.pcop = popRegFromString (sym->usl.spillLoc->rname, getSize (sym->type), sym->usl.spillLoc->offset);
+          aop->size = getSize (sym->type);
+
+          return;
+        }
+    }
+
+  {
+    sym_link *type = operandType (op);
+    if (IS_PTR_CONST (type))
+      DEBUGpic14_emitcode (";", "%d aop type is const pointer", __LINE__);
+  }
+
+  /* must be in a register */
+  DEBUGpic14_emitcode (";", "%d register type nRegs=%d", __LINE__, sym->nRegs);
+  sym->aop = op->aop = aop = newAsmop (AOP_REG);
+  aop->size = sym->nRegs;
+  for (i = 0; i < sym->nRegs; i++)
+    aop->aopu.aop_reg[i] = sym->regs[i];
+}
+
+/*-----------------------------------------------------------------*/
+/* freeAsmop - free up the asmop given to an operand               */
+/*----------------------------------------------------------------*/
+void
+freeAsmop (operand * op, asmop * aaop, iCode * ic, bool pop)
+{
+  asmop *aop;
+
+  if (!op)
+    aop = aaop;
+  else
+    aop = op->aop;
+
+  if (!aop)
+    return;
+
+  aop->freed = TRUE;
+
+  /* all other cases just dealloc */
+  if (op)
+    {
+      op->aop = NULL;
+      if (IS_SYMOP (op))
+        {
+          OP_SYMBOL (op)->aop = NULL;
+          /* if the symbol has a spill */
+          if (SPIL_LOC (op))
+            SPIL_LOC (op)->aop = NULL;
+        }
+    }
+}
+
+/*-----------------------------------------------------------------*/
+/* pic14aopLiteral - string from a literal value                   */
+/*-----------------------------------------------------------------*/
+static unsigned int
+pic14aopLiteral (value * val, int offset)
+{
+  union
+  {
+    float f;
+    unsigned char c[4];
+  } fl;
+
+  /* if it is a float then it gets tricky */
+  /* otherwise it is fairly simple */
+  if (!IS_FLOAT (val->type))
+    {
+      unsigned long v = ulFromVal (val);
+
+      return ((v >> (offset * 8)) & 0xff);
+    }
+
+  /* it is type float */
+  fl.f = (float) floatFromVal (val);
+#ifdef WORDS_BIGENDIAN
+  return fl.c[3 - offset];
+#else
+  return fl.c[offset];
+#endif
+}
+
+/*-----------------------------------------------------------------*/
+/* aopGet - for fetching value of the aop                          */
+/*-----------------------------------------------------------------*/
+char *
+aopGet (asmop * aop, int offset, bool bit16, bool dname)
+{
+  //DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+  /* offset is greater than
+     size then zero */
+  assert (aop);
+  if (offset > (aop->size - 1) && aop->type != AOP_LIT)
+    return zero;
+
+  /* depending on type */
+  switch (aop->type)
+  {
+    case AOP_IMMD:
+      if (bit16)
+        SNPRINTF(buffer, sizeof(buffer), "%s", aop->aopu.aop_immd);
+      else if (offset)
+        SNPRINTF(buffer, sizeof(buffer), "(%s >> %d)", aop->aopu.aop_immd, offset * 8);
+      else
+        SNPRINTF(buffer, sizeof(buffer), "%s", aop->aopu.aop_immd);
+      DEBUGpic14_emitcode (";", "%d immd %s", __LINE__, buffer);
+      return Safe_strdup(buffer);
+
+    case AOP_DIR:
+      if (offset)
+        {
+          SNPRINTF(buffer, sizeof(buffer), "(%s + %d)", aop->aopu.aop_dir, offset);
+          DEBUGpic14_emitcode (";", "oops AOP_DIR did this %s\n", buffer);
+        }
+      else
+        SNPRINTF(buffer, sizeof(buffer), "%s", aop->aopu.aop_dir);
+      return Safe_strdup(buffer);
+
+    case AOP_REG:
+      //if (dname)
+      //    return aop->aopu.aop_reg[offset]->dname;
+      //else
+      return aop->aopu.aop_reg[offset]->name;
+
+    case AOP_CRY:
+      //pic14_emitcode(";","%d",__LINE__);
+      return aop->aopu.aop_dir;
+
+    case AOP_LIT:
+      SNPRINTF(buffer, sizeof(buffer), "0x%02x", pic14aopLiteral (aop->aopu.aop_lit, offset));
+      return Safe_strdup(buffer);
+
+    case AOP_STR:
+      aop->coff = offset;
+      if (strcmp (aop->aopu.aop_str[offset], "a") == 0 && dname)
+        return "acc";
+      DEBUGpic14_emitcode (";", "%d - %s", __LINE__, aop->aopu.aop_str[offset]);
+      return aop->aopu.aop_str[offset];
+
+    case AOP_PCODE:
+    {
+      pCodeOp *pcop = aop->aopu.pcop;
+      DEBUGpic14_emitcode (";", "%d: aopGet AOP_PCODE type %s", __LINE__, pCodeOpType (pcop));
+      if (pcop->name)
+        {
+          if (pcop->type == PO_IMMEDIATE)
+            {
+              offset += PCOI (pcop)->index;
+            }
+
+          if (offset)
+            {
+              DEBUGpic14_emitcode (";", "%s offset %d", pcop->name, offset);
+              SNPRINTF(buffer, sizeof(buffer), "(%s+%d)", pcop->name, offset);
+            }
+          else
+            {
+              DEBUGpic14_emitcode (";", "%s", pcop->name);
+              SNPRINTF(buffer, sizeof(buffer), "%s", pcop->name);
+            }
+        }
+      else
+        SNPRINTF(buffer, sizeof(buffer), "0x%02x", PCOI (aop->aopu.pcop)->offset);
+    }
+
+    return Safe_strdup(buffer);
+  }
+
+  werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "aopget got unsupported aop->type");
+  exit (0);
+}
+
+/*-----------------------------------------------------------------*/
+/* popGetTempReg - create a new temporary pCodeOp                  */
+/*-----------------------------------------------------------------*/
+static pCodeOp *
+popGetTempReg (void)
+{
+
+  pCodeOp *pcop;
+
+  pcop = newpCodeOp (NULL, PO_GPR_TEMP);
+  if (pcop && pcop->type == PO_GPR_TEMP && PCOR (pcop)->r)
+    {
+      PCOR (pcop)->r->wasUsed = TRUE;
+      PCOR (pcop)->r->isFree = FALSE;
+    }
+
+  return pcop;
+}
+
+/*-----------------------------------------------------------------*/
+/* popReleaseTempReg - create a new temporary pCodeOp                  */
+/*-----------------------------------------------------------------*/
+static void
+popReleaseTempReg (pCodeOp * pcop)
+{
+
+  if (pcop && pcop->type == PO_GPR_TEMP && PCOR (pcop)->r)
+    PCOR (pcop)->r->isFree = TRUE;
+
+}
+
+/*-----------------------------------------------------------------*/
+/* popGetLabel - create a new pCodeOp of type PO_LABEL             */
+/*-----------------------------------------------------------------*/
+pCodeOp *
+popGetLabel (unsigned int key)
+{
+
+  DEBUGpic14_emitcode ("; ***", "%s  key=%d, label offset %d", __FUNCTION__, key, labelOffset);
+
+  if (key > (unsigned int) max_key)
+    max_key = key;
+
+  return newpCodeOpLabel (NULL, labelKey2num (key + labelOffset));
+}
+
+/*-------------------------------------------------------------------*/
+/* popGetHighLabel - create a new pCodeOp of type PO_LABEL with offset=1 */
+/*-------------------------------------------------------------------*/
+static pCodeOp *
+popGetHighLabel (unsigned int key)
+{
+  pCodeOp *pcop;
+  pcop = popGetLabel (key);
+  PCOLAB (pcop)->offset = 1;
+  return pcop;
+}
+
+/*-----------------------------------------------------------------*/
+/* popGetLit - asm operator to pcode operator conversion               */
+/*-----------------------------------------------------------------*/
+pCodeOp *
+popGetLit (unsigned int lit)
+{
+
+  return newpCodeOpLit ((unsigned char) lit);
+}
+
+/*-----------------------------------------------------------------*/
+/* popGetImmd - asm operator to pcode immediate conversion         */
+/*-----------------------------------------------------------------*/
+static pCodeOp *
+popGetImmd (const char *name, unsigned int offset, int index, int is_func)
+{
+
+  return newpCodeOpImmd (name, offset, index, 0, is_func);
+}
+
+/*-----------------------------------------------------------------*/
+/* popGetWithString - asm operator to pcode operator conversion            */
+/*-----------------------------------------------------------------*/
+static pCodeOp *
+popGetWithString (const char *str, int isExtern)
+{
+  pCodeOp *pcop;
+
+
+  if (!str)
+    {
+      fprintf (stderr, "NULL string %s %d\n", __FILE__, __LINE__);
+      exit (1);
+    }
+
+  pcop = newpCodeOp (str, PO_STR);
+  PCOS (pcop)->isPublic = isExtern ? 1 : 0;
+
+  return pcop;
+}
+
+pCodeOp *
+popGetExternal (const char *str, int isReg)
+{
+  pCodeOp *pcop;
+
+  if (isReg)
+    {
+      pcop = newpCodeOpRegFromStr (str);
+    }
+  else
+    {
+      pcop = popGetWithString (str, 1);
+    }
+
+  if (str)
+    {
+      symbol *sym;
+
+      for (sym = setFirstItem (externs); sym; sym = setNextItem (externs))
+        {
+          if (!strcmp (str, sym->rname))
+            break;
+        }
+
+      if (!sym)
+        {
+          sym = newSymbol (str, 0);
+          strncpy (sym->rname, str, SDCC_NAME_MAX);
+          addSet (&externs, sym);
+        }                       // if
+      sym->used++;
+    }
+  return pcop;
+}
+
+/*-----------------------------------------------------------------*/
+/* popRegFromString -                                              */
+/*-----------------------------------------------------------------*/
+static pCodeOp *
+popRegFromString (const char *str, int size, int offset)
+{
+
+  pCodeOp *pcop = Safe_alloc(sizeof(pCodeOpReg));
+  pcop->type = PO_DIR;
+
+  DEBUGpic14_emitcode (";", "%d", __LINE__);
+
+  if (!str)
+    str = "BAD_STRING";
+
+  pcop->name = Safe_strdup(str);
+
+  //pcop->name = Safe_strdup( ( (str) ? str : "BAD STRING"));
+
+  PCOR (pcop)->r = dirregWithName (pcop->name);
+  if (PCOR (pcop)->r == NULL)
+    {
+      //fprintf(stderr,"%d - couldn't find %s in allocated registers, size =%d\n",__LINE__,aop->aopu.aop_dir,aop->size);
+      PCOR (pcop)->r = allocRegByName (pcop->name, size);
+      DEBUGpic14_emitcode (";", "%d  %s   offset=%d - had to alloc by reg name", __LINE__, pcop->name, offset);
+    }
+  else
+    {
+      DEBUGpic14_emitcode (";", "%d  %s   offset=%d", __LINE__, pcop->name, offset);
+    }
+  PCOR (pcop)->instance = offset;
+
+  return pcop;
+}
+
+/*-----------------------------------------------------------------*/
+/*-----------------------------------------------------------------*/
+static pCodeOp *
+popRegFromIdx (int rIdx)
+{
+  pCodeOp *pcop;
+
+  DEBUGpic14_emitcode ("; ***", "%s,%d  , rIdx=0x%x", __FUNCTION__, __LINE__, rIdx);
+
+  pcop = Safe_alloc(sizeof(pCodeOpReg));
+
+  PCOR (pcop)->rIdx = rIdx;
+  PCOR (pcop)->r = typeRegWithIdx (rIdx, REG_STK, 1);
+  PCOR (pcop)->r->isFree = FALSE;
+  PCOR (pcop)->r->wasUsed = TRUE;
+
+  pcop->type = PCOR (pcop)->r->pc_type;
+
+
+  return pcop;
+}
+
+/*-----------------------------------------------------------------*/
+/* popGet - asm operator to pcode operator conversion              */
+/*-----------------------------------------------------------------*/
+pCodeOp *
+popGet (asmop * aop, int offset)        //, bool bit16, bool dname)
+{
+  //char *s = buffer ;
+  //char *rs;
+
+  pCodeOp *pcop;
+
+  //DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+  /* offset is greater than
+     size then zero */
+
+  assert (aop);
+
+
+  /* XXX: still needed for BIT operands (AOP_CRY) */
+  if ((offset >= aop->size) && (aop->type != AOP_LIT) && (aop->type != AOP_PCODE))
+    {
+      printf ("%s: (offset[%d] >= AOP_SIZE(op)[%d]) && (AOP_TYPE(op)[%d] != { AOP_LIT, AOP_PCODE })\n",
+              __FUNCTION__, offset, aop->size, aop->type);
+      return NULL;              //zero;
+    }
+
+  /* depending on type */
+  switch (aop->type)
+    {
+
+    case AOP_IMMD:
+      DEBUGpic14_emitcode (";", "%d", __LINE__);
+      return popGetImmd (aop->aopu.aop_immd, offset, 0, 0);
+
+    case AOP_DIR:
+      return popRegFromString (aop->aopu.aop_dir, aop->size, offset);
+
+    case AOP_REG:
+    {
+      int rIdx;
+      assert (offset < aop->size);
+      rIdx = aop->aopu.aop_reg[offset]->rIdx;
+
+      pcop = Safe_alloc(sizeof(pCodeOpReg));
+      PCOR (pcop)->rIdx = rIdx;
+      PCOR (pcop)->r = pic14_regWithIdx (rIdx);
+      PCOR (pcop)->r->wasUsed = TRUE;
+      PCOR (pcop)->r->isFree = FALSE;
+
+      PCOR (pcop)->instance = offset;
+      pcop->type = PCOR (pcop)->r->pc_type;
+      //rs = aop->aopu.aop_reg[offset]->name;
+      DEBUGpic14_emitcode (";", "%d rIdx = r0x%X ", __LINE__, rIdx);
+      return pcop;
+    }
+
+    case AOP_CRY:
+      pcop = newpCodeOpBit (aop->aopu.aop_dir, -1, 1);
+      PCOR (pcop)->r = dirregWithName (aop->aopu.aop_dir);
+      //if(PCOR(pcop)->r == NULL)
+      //fprintf(stderr,"%d - couldn't find %s in allocated registers\n",__LINE__,aop->aopu.aop_dir);
+      return pcop;
+
+    case AOP_LIT:
+      return newpCodeOpLit (pic14aopLiteral (aop->aopu.aop_lit, offset));
+
+    case AOP_STR:
+      DEBUGpic14_emitcode (";", "%d  %s", __LINE__, aop->aopu.aop_str[offset]);
+      return newpCodeOpRegFromStr (aop->aopu.aop_str[offset]);
+
+    case AOP_PCODE:
+      pcop = NULL;
+      DEBUGpic14_emitcode (";", "popGet AOP_PCODE (%s + %i) %d %s", pCodeOpType (aop->aopu.pcop), offset,
+                           __LINE__, ((aop->aopu.pcop->name) ? (aop->aopu.pcop->name) : "no name"));
+      //emitpComment ("popGet; name %s, offset: %i, pcop-type: %s\n", aop->aopu.pcop->name, offset, pCodeOpType (aop->aopu.pcop));
+      switch (aop->aopu.pcop->type)
+        {
+        case PO_IMMEDIATE:
+          pcop = pCodeOpCopy (aop->aopu.pcop);
+          /* usually we want to access the memory at "<symbol> + offset" (using ->index),
+           * but sometimes we want to access the high byte of the symbol's address (using ->offset) */
+          PCOI (pcop)->index += offset;
+          //PCOI(pcop)->offset = 0;
+          break;
+        case PO_DIR:
+          pcop = pCodeOpCopy (aop->aopu.pcop);
+          PCOR (pcop)->instance = offset;
+          break;
+        default:
+          assert (!"unhandled pCode type");
+          break;
+        }                       // switch
+      return pcop;
+    }
+
+  werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "popGet got unsupported aop->type");
+  exit (0);
+}
+
+/*-----------------------------------------------------------------*/
+/* popGetAddr - access the low/high word of a symbol (immediate)   */
+/*              (for non-PO_IMMEDIATEs this is the same as popGet) */
+/*-----------------------------------------------------------------*/
+pCodeOp *
+popGetAddr (asmop * aop, int offset, int index)
+{
+  if (aop->type == AOP_PCODE && aop->aopu.pcop->type == PO_IMMEDIATE)
+    {
+      pCodeOp *pcop = aop->aopu.pcop;
+      assert (offset <= GPTRSIZE);
+
+      /* special case: index >= 2 should return GPOINTER-style values */
+      if (offset == 2)
+        {
+          pcop = popGetLit (aop->code ? GPTRTAG_CODE : GPTRTAG_DATA);
+          return pcop;
+        }
+
+      pcop = pCodeOpCopy (pcop);
+      /* usually we want to access the memory at "<symbol> + offset" (using ->index),
+       * but sometimes we want to access the high byte of the symbol's address (using ->offset) */
+      PCOI (pcop)->offset += offset;
+      PCOI (pcop)->index += index;
+      //fprintf (stderr, "is PO_IMMEDIATE: %s+o%d+i%d (new o%d,i%d)\n", pcop->name,PCOI(pcop)->offset,PCOI(pcop)->index, offset, index);
+      return pcop;
+    }
+  else
+    {
+      return popGet (aop, offset + index);
+    }
+}
+
+/*-----------------------------------------------------------------*/
+/* aopPut - puts a string for a aop                                */
+/*-----------------------------------------------------------------*/
+void
+aopPut (asmop * aop, const char *s, int offset)
+{
+  symbol *lbl;
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+  if (aop->size && offset > (aop->size - 1))
+    {
+      werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "aopPut got offset > aop->size");
+      exit (0);
+    }
+
+  /* will assign value to value */
+  /* depending on where it is ofcourse */
+  switch (aop->type)
+    {
+    case AOP_DIR:
+      if (offset)
+        {
+          SNPRINTF(buffer, sizeof(buffer), "(%s + %d)", aop->aopu.aop_dir, offset);
+          fprintf (stderr, "oops aopPut:AOP_DIR did this %s\n", s);
+        }
+      else
+        SNPRINTF(buffer, sizeof(buffer), "%s", aop->aopu.aop_dir);
+
+      if (strcmp (buffer, s))
+        {
+          DEBUGpic14_emitcode (";", "%d", __LINE__);
+          if (strcmp (s, "W"))
+            pic14_emitcode ("movf", "%s,w", s);
+
+          pic14_emitcode ("movwf", "%s", buffer);
+
+          if (strcmp (s, "W"))
+            {
+              pic14_emitcode (";BUG!? should have this:movf", "%s,w   %d", s, __LINE__);
+              if (offset >= aop->size)
+                {
+                  emitpcode (POC_CLRF, popGet (aop, offset));
+                  break;
+                }
+              else
+                {
+                  emitpcode (POC_MOVFW, popGetImmd (s, 0, offset, 0));
+                }
+            }
+          emitpcode (POC_MOVWF, popGet (aop, offset));
+        }
+      break;
+
+    case AOP_REG:
+      if (strcmp (aop->aopu.aop_reg[offset]->name, s) != 0)
+        {
+          if (strcmp (s, "W") == 0)
+            pic14_emitcode ("movf", "%s,w  ; %d", s, __LINE__);
+
+          pic14_emitcode ("movwf", "%s", aop->aopu.aop_reg[offset]->name);
+
+          if (strcmp (s, zero) == 0)
+            {
+              emitpcode (POC_CLRF, popGet (aop, offset));
+
+            }
+          else if (strcmp (s, "W") == 0)
+            {
+              pCodeOp *pcop = Safe_alloc(sizeof(pCodeOpReg));
+              pcop->type = PO_GPR_REGISTER;
+
+              PCOR (pcop)->rIdx = -1;
+              PCOR (pcop)->r = NULL;
+
+              DEBUGpic14_emitcode (";", "%d", __LINE__);
+              pcop->name = Safe_strdup (s);
+              emitpcode (POC_MOVFW, pcop);
+              emitpcode (POC_MOVWF, popGet (aop, offset));
+            }
+          else if (strcmp (s, one) == 0)
+            {
+              emitpcode (POC_CLRF, popGet (aop, offset));
+              emitpcode (POC_INCF, popGet (aop, offset));
+            }
+          else
+            {
+              emitpcode (POC_MOVWF, popGet (aop, offset));
+            }
+        }
+      break;
+
+    case AOP_STK:
+      if (strcmp (s, "a") == 0)
+        pic14_emitcode ("push", "acc");
+      else
+        pic14_emitcode ("push", "%s", s);
+      break;
+
+    case AOP_CRY:
+      /* if bit variable */
+      if (!aop->aopu.aop_dir)
+        {
+          pic14_emitcode ("clr", "a");
+          pic14_emitcode ("rlc", "a");
+        }
+      else
+        {
+          if (s == zero)
+            pic14_emitcode ("clr", "%s", aop->aopu.aop_dir);
+          else if (s == one)
+            pic14_emitcode ("setb", "%s", aop->aopu.aop_dir);
+          else if (!strcmp (s, "c"))
+            pic14_emitcode ("mov", "%s,c", aop->aopu.aop_dir);
+          else
+            {
+              lbl = newiTempLabel (NULL);
+
+              if (strcmp (s, "a"))
+                {
+                  MOVA (s);
+                }
+
+              pic14_emitcode ("clr", "c");
+              pic14_emitcode ("jz", "%05d_DS_", labelKey2num (lbl->key));
+              pic14_emitcode ("cpl", "c");
+              pic14_emitcode ("", "%05d_DS_:", labelKey2num (lbl->key));
+              pic14_emitcode ("mov", "%s,c", aop->aopu.aop_dir);
+            }
+        }
+      break;
+
+    case AOP_STR:
+      aop->coff = offset;
+      if (strcmp (aop->aopu.aop_str[offset], s))
+        pic14_emitcode ("mov", "%s,%s ; %d", aop->aopu.aop_str[offset], s, __LINE__);
+      break;
+
+    default:
+      werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "aopPut got unsupported aop->type");
+      exit(0);
+    }
+}
+
+/*-----------------------------------------------------------------*/
+/* mov2w_op - generate either a MOVLW or MOVFW based operand type  */
+/*-----------------------------------------------------------------*/
+static void
+mov2w_op (operand * op, int offset)
+{
+  assert (op);
+  FENTRY;
+
+  /* for PO_IMMEDIATEs: use address or value? */
+  if (op_isLitLike (op))
+    {
+      /* access address of op */
+      if (AOP_TYPE (op) != AOP_LIT)
+        {
+          assert (offset < 3);
+        }
+      if (IS_SYMOP (op) && IS_GENPTR (OP_SYM_TYPE (op)) && AOP_SIZE (op) < offset)
+        {
+          if (offset == GPTRSIZE - 1)
+            emitpcode (POC_MOVLW, popGetLit (GPTRTAG_DATA));
+          else
+            emitpcode (POC_MOVLW, popGetLit (0));
+        }
+      else
+        emitpcode (POC_MOVLW, popGetAddr (AOP (op), offset, 0));
+    }
+  else
+    {
+      /* access value stored in op */
+      mov2w (AOP (op), offset);
+    }
+}
+
+
+/*-----------------------------------------------------------------*/
+/* mov2w - generate either a MOVLW or MOVFW based operand type     */
+/*-----------------------------------------------------------------*/
+void
+mov2w (asmop * aop, int offset)
+{
+
+  if (!aop)
+    return;
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d  offset=%d", __FUNCTION__, __LINE__, offset);
+
+  if (aop_isLitLike (aop))
+    emitpcode (POC_MOVLW, popGetAddr (aop, offset, 0));
+  else
+    emitpcode (POC_MOVFW, popGet (aop, offset));
+
+}
+
+static void
+movwf (asmop * op, int offset)
+{
+  emitpcode (POC_MOVWF, popGet (op, offset));
+}
+
+static pCodeOp *
+get_argument_pcop (int idx)
+{
+  assert (idx > 0 && "the 0th (first) argument is passed via WREG");
+  return popRegFromIdx (Gstack_base_addr - (idx - 1));
+}
+
+static pCodeOp *
+get_return_val_pcop (int offset)
+{
+  assert (offset > 0 && "the most significant byte is returned via WREG");
+  return popRegFromIdx (Gstack_base_addr - (offset - 1));
+}
+
+static void
+pass_argument (operand * op, int offset, int idx)
+{
+  if (op)
+    mov2w_op (op, offset);
+  if (idx != 0)
+    emitpcode (POC_MOVWF, get_argument_pcop (idx));
+}
+
+static void
+get_returnvalue (operand * op, int offset, int idx)
+{
+  if (idx != 0)
+    emitpcode (POC_MOVFW, get_return_val_pcop (idx));
+  movwf (AOP (op), offset);
+}
+
+static void
+call_libraryfunc (char *name)
+{
+  symbol *sym;
+
+  /* library code might reside in different page... */
+  emitpcode (POC_PAGESEL, popGetWithString (name, 1));
+  /* call the library function */
+  emitpcode (POC_CALL, popGetExternal (name, 0));
+  /* might return from different page... */
+  emitpcode (POC_PAGESEL, popGetWithString ("$", 0));
+
+  /* create symbol, mark it as `extern' */
+  sym = findSym (SymbolTab, NULL, name);
+  if (!sym)
+    {
+      sym = newSymbol (name, 0);
+      strncpy (sym->rname, name, SDCC_NAME_MAX);
+      addSym (SymbolTab, sym, sym->rname, 0, 0, 0);
+      addSet (&externs, sym);
+    }                           // if
+  sym->used++;
+}
+
+/*-----------------------------------------------------------------*/
+/* pic14_getDataSize - get the operand data size                   */
+/*-----------------------------------------------------------------*/
+int
+pic14_getDataSize (operand * op)
+{
+  int size;
+
+  size = AOP_SIZE (op);
+  return size;
+}
+
+/*-----------------------------------------------------------------*/
+/* pic14_outAcc - output Acc                                       */
+/*-----------------------------------------------------------------*/
+void
+pic14_outAcc (operand * result)
+{
+  int size, offset;
+  DEBUGpic14_emitcode ("; ***", "%s  %d - ", __FUNCTION__, __LINE__);
+  DEBUGpic14_AopType (__LINE__, NULL, NULL, result);
+
+
+  size = pic14_getDataSize (result);
+  if (size)
+    {
+      emitpcode (POC_MOVWF, popGet (AOP (result), 0));
+      size--;
+      offset = 1;
+      /* unsigned or positive */
+      while (size--)
+        emitpcode (POC_CLRF, popGet (AOP (result), offset++));
+    }
+
+}
+
+/*-----------------------------------------------------------------*/
+/* pic14_outBitC - output a bit C                                  */
+/*-----------------------------------------------------------------*/
+static void
+pic14_outBitC (operand * result)
+{
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  /* if the result is bit */
+  if (AOP_TYPE (result) == AOP_CRY)
+    aopPut (AOP (result), "c", 0);
+  else
+    {
+      pic14_emitcode ("clr", "a  ; %d", __LINE__);
+      pic14_emitcode ("rlc", "a");
+      pic14_outAcc (result);
+    }
+}
+
+/*-----------------------------------------------------------------*/
+/* pic14_toBoolean - emit code for orl a,operator(sizeop)          */
+/*-----------------------------------------------------------------*/
+static void
+pic14_toBoolean (operand * oper)
+{
+  int size = AOP_SIZE (oper);
+  int offset = 0;
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+  assert (size > 0);
+
+  if (size == 1)
+    {
+      /* MOVFW does not load the flags... */
+      emitpcode (POC_MOVLW, popGetLit (0));
+      offset = 0;
+    }
+  else
+    {
+      emitpcode (POC_MOVFW, popGet (AOP (oper), 0));
+      offset = 1;
+    }
+
+  while (offset < size)
+    {
+      emitpcode (POC_IORFW, popGet (AOP (oper), offset++));
+    }
+  /* Z is set iff (oper == 0) */
+}
+
+
+/*-----------------------------------------------------------------*/
+/* genNot - generate code for ! operation                          */
+/*-----------------------------------------------------------------*/
+static void
+genNot (iCode * ic)
+{
+  //symbol *tlbl;
+  int size;
+
+  FENTRY;
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  /* assign asmOps to operand & result */
+  aopOp (IC_LEFT (ic), ic, FALSE);
+  aopOp (IC_RESULT (ic), ic, TRUE);
+
+  DEBUGpic14_AopType (__LINE__, IC_LEFT (ic), NULL, IC_RESULT (ic));
+  /* if in bit space then a special case */
+  if (AOP_TYPE (IC_LEFT (ic)) == AOP_CRY)
+    {
+      if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY)
+        {
+          emitpcode (POC_MOVLW, popGet (AOP (IC_LEFT (ic)), 0));
+          emitpcode (POC_XORWF, popGet (AOP (IC_RESULT (ic)), 0));
+        }
+      else
+        {
+          emitpcode (POC_CLRF, popGet (AOP (IC_RESULT (ic)), 0));
+          emitpcode (POC_BTFSS, popGet (AOP (IC_LEFT (ic)), 0));
+          emitpcode (POC_INCF, popGet (AOP (IC_RESULT (ic)), 0));
+        }
+      goto release;
+    }
+
+  size = AOP_SIZE (IC_LEFT (ic));
+  mov2w (AOP (IC_LEFT (ic)), 0);
+  while (--size > 0)
+    {
+      if (op_isLitLike (IC_LEFT (ic)))
+        emitpcode (POC_IORLW, popGetAddr (AOP (IC_LEFT (ic)), size, 0));
+      else
+        emitpcode (POC_IORFW, popGet (AOP (IC_LEFT (ic)), size));
+    }
+  emitpcode (POC_MOVLW, popGetLit (0));
+  emitSKPNZ;
+  emitpcode (POC_MOVLW, popGetLit (1));
+  movwf (AOP (IC_RESULT (ic)), 0);
+
+  for (size = 1; size < AOP_SIZE (IC_RESULT (ic)); size++)
+    {
+      emitpcode (POC_CLRF, popGet (AOP (IC_RESULT (ic)), size));
+    }
+  goto release;
+
+release:
+  /* release the aops */
+  freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? 0 : 1));
+  freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+}
+
+
+/*-----------------------------------------------------------------*/
+/* genCpl - generate code for complement                           */
+/*-----------------------------------------------------------------*/
+static void
+genCpl (iCode * ic)
+{
+  operand *left, *result;
+  int size, offset = 0;
+
+  FENTRY;
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  aopOp ((left = IC_LEFT (ic)), ic, FALSE);
+  aopOp ((result = IC_RESULT (ic)), ic, TRUE);
+
+  /* if both are in bit space then
+     a special case */
+  if (AOP_TYPE (result) == AOP_CRY && AOP_TYPE (left) == AOP_CRY)
+    {
+
+      pic14_emitcode ("mov", "c,%s", left->aop->aopu.aop_dir);
+      pic14_emitcode ("cpl", "c");
+      pic14_emitcode ("mov", "%s,c", result->aop->aopu.aop_dir);
+      goto release;
+    }
+
+  size = AOP_SIZE (result);
+  if (AOP_SIZE (left) < size)
+    size = AOP_SIZE (left);
+  while (size--)
+    {
+      emitpcode (POC_COMFW, popGet (AOP (left), offset));
+      emitpcode (POC_MOVWF, popGet (AOP (result), offset));
+      offset++;
+    }
+  addSign (result, AOP_SIZE (left), !SPEC_USIGN (operandType (result)));
+
+
+release:
+  /* release the aops */
+  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? 0 : 1));
+  freeAsmop (result, NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genUminusFloat - unary minus for floating points                */
+/*-----------------------------------------------------------------*/
+static void
+genUminusFloat (operand * op, operand * result)
+{
+  int size;
+
+  FENTRY;
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  /* for this we just need to flip the
+     first it then copy the rest in place */
+  size = AOP_SIZE (op) - 1;
+
+  mov2w_op (op, size);
+  emitpcode (POC_XORLW, popGetLit (0x80));
+  movwf (AOP (result), size);
+
+  while (size--)
+    {
+      mov2w_op (op, size);
+      movwf (AOP (result), size);
+    }                           // while
+}
+
+/*-----------------------------------------------------------------*/
+/* genUminus - unary minus code generation                         */
+/*-----------------------------------------------------------------*/
+static void
+genUminus (iCode * ic)
+{
+  int size, i;
+  sym_link *optype;
+
+  FENTRY;
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  /* assign asmops */
+  aopOp (IC_LEFT (ic), ic, FALSE);
+  aopOp (IC_RESULT (ic), ic, TRUE);
+
+  /* if both in bit space then special
+     case */
+  if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY && AOP_TYPE (IC_LEFT (ic)) == AOP_CRY)
+    {
+
+      emitpcode (POC_BCF, popGet (AOP (IC_RESULT (ic)), 0));
+      emitpcode (POC_BTFSS, popGet (AOP (IC_LEFT (ic)), 0));
+      emitpcode (POC_BSF, popGet (AOP (IC_RESULT (ic)), 0));
+
+      goto release;
+    }
+
+  optype = operandType (IC_LEFT (ic));
+
+  /* if float then do float stuff */
+  if (IS_FLOAT (optype))
+    {
+      genUminusFloat (IC_LEFT (ic), IC_RESULT (ic));
+      goto release;
+    }
+
+  /* otherwise subtract from zero by taking the 2's complement */
+  size = AOP_SIZE (IC_LEFT (ic));
+
+  for (i = 0; i < size; i++)
+    {
+      if (pic14_sameRegs (AOP (IC_LEFT (ic)), AOP (IC_RESULT (ic))))
+        emitpcode (POC_COMF, popGet (AOP (IC_LEFT (ic)), i));
+      else
+        {
+          emitpcode (POC_COMFW, popGet (AOP (IC_LEFT (ic)), i));
+          emitpcode (POC_MOVWF, popGet (AOP (IC_RESULT (ic)), i));
+        }
+    }
+
+  emitpcode (POC_INCF, popGet (AOP (IC_RESULT (ic)), 0));
+  for (i = 1; i < size; i++)
+    {
+      emitSKPNZ;
+      emitpcode (POC_INCF, popGet (AOP (IC_RESULT (ic)), i));
+    }
+
+release:
+  /* release the aops */
+  freeAsmop (IC_LEFT (ic), NULL, ic, (RESULTONSTACK (ic) ? 0 : 1));
+  freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* saverbank - saves an entire register bank on the stack          */
+/*-----------------------------------------------------------------*/
+static void
+saverbank (int bank, iCode * ic, bool pushPsw)
+{
+  FENTRY;
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d - WARNING no code generated", __FUNCTION__, __LINE__);
+#if 0
+  int i;
+  asmop *aop;
+  regs *r = NULL;
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  if (options.useXstack)
+    {
+
+      aop = newAsmop (0);
+      r = getFreePtr (ic, &aop, FALSE);
+      pic14_emitcode ("mov", "%s,_spx", r->name);
+
+    }
+
+  for (i = 0; i < pic14_nRegs; i++)
+    {
+      if (options.useXstack)
+        {
+          pic14_emitcode ("inc", "%s", r->name);
+          //pic14_emitcode("mov","a,(%s+%d)",
+          //       regspic14[i].base,8*bank+regspic14[i].offset);
+          pic14_emitcode ("movx", "@%s,a", r->name);
+        }
+      else
+        pic14_emitcode ("push", "");    // "(%s+%d)",
+      //regspic14[i].base,8*bank+regspic14[i].offset);
+    }
+
+  if (pushPsw)
+    {
+      if (options.useXstack)
+        {
+          pic14_emitcode ("mov", "a,psw");
+          pic14_emitcode ("movx", "@%s,a", r->name);
+          pic14_emitcode ("inc", "%s", r->name);
+          pic14_emitcode ("mov", "_spx,%s", r->name);
+          freeAsmop (NULL, aop, ic, TRUE);
+
+        }
+      else
+        pic14_emitcode ("push", "psw");
+
+      pic14_emitcode ("mov", "psw,#0x%02x", (bank << 3) & 0x00ff);
+    }
+  ic->bankSaved = 1;
+#endif
+}
+
+/*-----------------------------------------------------------------*/
+/* saveRegisters - will look for a call and save the registers     */
+/*-----------------------------------------------------------------*/
+static void
+saveRegisters (iCode * lic)
+{
+  iCode *ic;
+  sym_link *dtype;
+
+  FENTRY;
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+  /* look for call */
+  for (ic = lic; ic; ic = ic->next)
+    if (ic->op == CALL || ic->op == PCALL)
+      break;
+
+  if (!ic)
+    {
+      fprintf (stderr, "found parameter push with no function call\n");
+      return;
+    }
+
+  /* if the registers have been saved already then do nothing */
+  if (ic->regsSaved || IFFUNC_CALLEESAVES (OP_SYMBOL (IC_LEFT (ic))->type))
+    return;
+
+  /* find the registers in use at this time
+     and push them away to safety */
+  bitVectCplAnd (bitVectCopy (ic->rMask), ic->rUsed);
+
+  ic->regsSaved = 1;
+
+  //fprintf(stderr, "ERROR: saveRegisters did not do anything to save registers, please report this as a bug.\n");
+
+  dtype = operandType (IC_LEFT (ic));
+  if (currFunc && dtype &&
+      (FUNC_REGBANK (currFunc->type) != FUNC_REGBANK (dtype)) && IFFUNC_ISISR (currFunc->type) && !ic->bankSaved)
+    {
+      saverbank (FUNC_REGBANK (dtype), ic, TRUE);
+    }
+}
+
+/*-----------------------------------------------------------------*/
+/* unsaveRegisters - pop the pushed registers                      */
+/*-----------------------------------------------------------------*/
+static void
+unsaveRegisters (iCode * ic)
+{
+  int i;
+  bitVect *rsave;
+
+  FENTRY;
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  /* find the registers in use at this time
+     and push them away to safety */
+  rsave = bitVectCplAnd (bitVectCopy (ic->rMask), ic->rUsed);
+
+  if (options.useXstack)
+    {
+      pic14_emitcode ("mov", "r0,%s", spname);
+      for (i = pic14_nRegs; i >= 0; i--)
+        {
+          if (bitVectBitValue (rsave, i))
+            {
+              pic14_emitcode ("dec", "r0");
+              pic14_emitcode ("movx", "a,@r0");
+              pic14_emitcode ("mov", "%s,a", pic14_regWithIdx (i)->name);
+            }
+
+        }
+      pic14_emitcode ("mov", "%s,r0", spname);
+    }                           //else
+  //for (i =  pic14_nRegs ; i >= 0 ; i--) {
+  //  if (bitVectBitValue(rsave,i))
+  //  pic14_emitcode("pop","%s",pic14_regWithIdx(i)->dname);
+  //}
+
+}
+
+
+/*-----------------------------------------------------------------*/
+/* pushSide -                */
+/*-----------------------------------------------------------------*/
+static void
+pushSide (operand * oper, int size)
+{
+#if 0
+  int offset = 0;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  while (size--)
+    {
+      char *l = aopGet (AOP (oper), offset++, FALSE, TRUE);
+      if (AOP_TYPE (oper) != AOP_REG && AOP_TYPE (oper) != AOP_DIR && strcmp (l, "a"))
+        {
+          pic14_emitcode ("mov", "a,%s", l);
+          pic14_emitcode ("push", "acc");
+        }
+      else
+        pic14_emitcode ("push", "%s", l);
+    }
+#endif
+}
+
+/*-----------------------------------------------------------------*/
+/* assignResultValue -               */
+/*-----------------------------------------------------------------*/
+static void
+assignResultValue (operand * oper)
+{
+  int size = AOP_SIZE (oper);
+  int offset = 0;
+
+  FENTRY;
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+  DEBUGpic14_AopType (__LINE__, oper, NULL, NULL);
+
+  /* assign MSB first (passed via WREG) */
+  while (size--)
+    {
+      get_returnvalue (oper, size, offset + GpseudoStkPtr);
+      GpseudoStkPtr++;
+    }
+}
+
+
+/*-----------------------------------------------------------------*/
+/* genIpush - genrate code for pushing this gets a little complex  */
+/*-----------------------------------------------------------------*/
+static void
+genIpush (iCode * ic)
+{
+  FENTRY;
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d - WARNING no code generated", __FUNCTION__, __LINE__);
+#if 0
+  int size, offset = 0;
+  char *l;
+
+
+  /* if this is not a parm push : ie. it is spill push
+     and spill push is always done on the local stack */
+  if (!ic->parmPush)
+    {
+
+      /* and the item is spilt then do nothing */
+      if (OP_SYMBOL (IC_LEFT (ic))->isspilt)
+        return;
+
+      aopOp (IC_LEFT (ic), ic, FALSE);
+      size = AOP_SIZE (IC_LEFT (ic));
+      /* push it on the stack */
+      while (size--)
+        {
+          l = aopGet (AOP (IC_LEFT (ic)), offset++, FALSE, TRUE);
+          if (*l == '#')
+            {
+              MOVA (l);
+              l = "acc";
+            }
+          pic14_emitcode ("push", "%s", l);
+        }
+      return;
+    }
+
+  /* this is a paramter push: in this case we call
+     the routine to find the call and save those
+     registers that need to be saved */
+  saveRegisters (ic);
+
+  /* then do the push */
+  aopOp (IC_LEFT (ic), ic, FALSE);
+
+
+  // pushSide(IC_LEFT(ic), AOP_SIZE(IC_LEFT(ic)));
+  size = AOP_SIZE (IC_LEFT (ic));
+
+  while (size--)
+    {
+      l = aopGet (AOP (IC_LEFT (ic)), offset++, FALSE, TRUE);
+      if (AOP_TYPE (IC_LEFT (ic)) != AOP_REG && AOP_TYPE (IC_LEFT (ic)) != AOP_DIR && strcmp (l, "a"))
+        {
+          pic14_emitcode ("mov", "a,%s", l);
+          pic14_emitcode ("push", "acc");
+        }
+      else
+        pic14_emitcode ("push", "%s", l);
+    }
+
+  freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
+#endif
+}
+
+/*-----------------------------------------------------------------*/
+/* genIpop - recover the registers: can happen only for spilling   */
+/*-----------------------------------------------------------------*/
+static void
+genIpop (iCode * ic)
+{
+  FENTRY;
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d - WARNING no code generated", __FUNCTION__, __LINE__);
+  assert (!"genIpop -- unimplemented");
+#if 0
+  int size, offset;
+
+
+  /* if the temp was not pushed then */
+  if (OP_SYMBOL (IC_LEFT (ic))->isspilt)
+    return;
+
+  aopOp (IC_LEFT (ic), ic, FALSE);
+  size = AOP_SIZE (IC_LEFT (ic));
+  offset = (size - 1);
+  while (size--)
+    pic14_emitcode ("pop", "%s", aopGet (AOP (IC_LEFT (ic)), offset--, FALSE, TRUE));
+
+  freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
+#endif
+}
+
+/*-----------------------------------------------------------------*/
+/* unsaverbank - restores the resgister bank from stack            */
+/*-----------------------------------------------------------------*/
+static void
+unsaverbank (int bank, iCode * ic, bool popPsw)
+{
+  FENTRY;
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d - WARNING no code generated", __FUNCTION__, __LINE__);
+#if 0
+  int i;
+  asmop *aop;
+  regs *r = NULL;
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  if (popPsw)
+    {
+      if (options.useXstack)
+        {
+          aop = newAsmop (0);
+          r = getFreePtr (ic, &aop, FALSE);
+
+
+          pic14_emitcode ("mov", "%s,_spx", r->name);
+          pic14_emitcode ("movx", "a,@%s", r->name);
+          pic14_emitcode ("mov", "psw,a");
+          pic14_emitcode ("dec", "%s", r->name);
+
+        }
+      else
+        pic14_emitcode ("pop", "psw");
+    }
+
+  for (i = (pic14_nRegs - 1); i >= 0; i--)
+    {
+      if (options.useXstack)
+        {
+          pic14_emitcode ("movx", "a,@%s", r->name);
+          //pic14_emitcode("mov","(%s+%d),a",
+          //     regspic14[i].base,8*bank+regspic14[i].offset);
+          pic14_emitcode ("dec", "%s", r->name);
+
+        }
+      else
+        pic14_emitcode ("pop", "");     //"(%s+%d)",
+      //regspic14[i].base,8*bank); //+regspic14[i].offset);
+    }
+
+  if (options.useXstack)
+    {
+
+      pic14_emitcode ("mov", "_spx,%s", r->name);
+      freeAsmop (NULL, aop, ic, TRUE);
+
+    }
+#endif
+}
+
+/*-----------------------------------------------------------------*/
+/* genCall - generates a call statement                            */
+/*-----------------------------------------------------------------*/
+static void
+genCall (iCode * ic)
+{
+  sym_link *dtype;
+  symbol *sym;
+  char *name;
+  int isExtern;
+
+  FENTRY;
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+  /* if caller saves & we have not saved then */
+  if (!ic->regsSaved)
+    saveRegisters (ic);
+
+  /* if we are calling a function that is not using
+     the same register bank then we need to save the
+     destination registers on the stack */
+  dtype = operandType (IC_LEFT (ic));
+  if (currFunc && dtype &&
+      (FUNC_REGBANK (currFunc->type) != FUNC_REGBANK (dtype)) && IFFUNC_ISISR (currFunc->type) && !ic->bankSaved)
+
+    saverbank (FUNC_REGBANK (dtype), ic, TRUE);
+
+  /* if send set is not empty the assign */
+  if (_G.sendSet)
+    {
+      iCode *sic;
+      /* For the Pic port, there is no data stack.
+       * So parameters passed to functions are stored
+       * in registers. (The pCode optimizer will get
+       * rid of most of these :).
+       */
+      int pseudoStkPtr = -1;
+      int firstTimeThruLoop = 1;
+
+      _G.sendSet = reverseSet (_G.sendSet);
+
+      /* First figure how many parameters are getting passed */
+      for (sic = setFirstItem (_G.sendSet); sic; sic = setNextItem (_G.sendSet))
+        {
+
+          aopOp (IC_LEFT (sic), sic, FALSE);
+          pseudoStkPtr += AOP_SIZE (IC_LEFT (sic));
+          freeAsmop (IC_LEFT (sic), NULL, sic, FALSE);
+        }
+
+      for (sic = setFirstItem (_G.sendSet); sic; sic = setNextItem (_G.sendSet))
+        {
+          int size, offset = 0;
+
+          aopOp (IC_LEFT (sic), sic, FALSE);
+          size = AOP_SIZE (IC_LEFT (sic));
+
+          while (size--)
+            {
+              DEBUGpic14_emitcode ("; ", "%d left %s", __LINE__, AopType (AOP_TYPE (IC_LEFT (sic))));
+
+              if (!firstTimeThruLoop)
+                {
+                  /* If this is not the first time we've been through the loop
+                   * then we need to save the parameter in a temporary
+                   * register. The last byte of the last parameter is
+                   * passed in W. */
+                  emitpcode (POC_MOVWF, popRegFromIdx (Gstack_base_addr - --pseudoStkPtr));
+
+                }
+              firstTimeThruLoop = 0;
+
+              mov2w_op (IC_LEFT (sic), offset);
+              offset++;
+            }
+          freeAsmop (IC_LEFT (sic), NULL, sic, TRUE);
+        }
+      _G.sendSet = NULL;
+    }
+  /* make the call */
+  sym = OP_SYMBOL (IC_LEFT (ic));
+  name = sym->rname[0] ? sym->rname : sym->name;
+  /*
+   * As SDCC emits code as soon as it reaches the end of each
+   * function's definition, prototyped functions that are implemented
+   * after the current one are always considered EXTERN, which
+   * introduces many unneccessary PAGESEL instructions.
+   * XXX: Use a post pass to iterate over all `CALL _name' statements
+   * and insert `PAGESEL _name' and `PAGESEL $' around the CALL
+   * only iff there is no definition of the function in the whole
+   * file (might include this in the PAGESEL pass).
+   */
+  isExtern = IS_EXTERN (sym->etype) || pic14_inISR;
+#if 0
+  if (isExtern)
+    {
+      /* Extern functions and ISRs maybe on a different page;
+       * must call pagesel */
+#endif
+      emitpcode (POC_PAGESEL, popGetWithString (name, 1));
+#if 0
+    }
+#endif
+
+  emitpcode (POC_CALL, popGetWithString (name, isExtern));
+#if 0
+  if (isExtern)
+    {
+      /* May have returned from a different page;
+       * must use pagesel to restore PCLATH before next
+       * goto or call instruction */
+#endif
+      emitpcode (POC_PAGESEL, popGetWithString ("$", 0));
+#if 0
+    }
+#endif
+  GpseudoStkPtr = 0;
+  /* if we need assign a result value */
+  if ((IS_ITEMP (IC_RESULT (ic)) &&
+       (OP_SYMBOL (IC_RESULT (ic))->nRegs || OP_SYMBOL (IC_RESULT (ic))->spildir)) || IS_TRUE_SYMOP (IC_RESULT (ic)))
+    {
+      _G.accInUse++;
+      aopOp (IC_RESULT (ic), ic, FALSE);
+      _G.accInUse--;
+
+      assignResultValue (IC_RESULT (ic));
+
+      DEBUGpic14_emitcode ("; ", "%d left %s", __LINE__, AopType (AOP_TYPE (IC_RESULT (ic))));
+
+      freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+    }
+
+  /* if register bank was saved then pop them */
+  if (ic->bankSaved)
+    unsaverbank (FUNC_REGBANK (dtype), ic, TRUE);
+
+  /* if we hade saved some registers then unsave them */
+  if (ic->regsSaved && !IFFUNC_CALLEESAVES (dtype))
+    unsaveRegisters (ic);
+}
+
+/*-----------------------------------------------------------------*/
+/* genPcall - generates a call by pointer statement                */
+/*-----------------------------------------------------------------*/
+static void
+genPcall (iCode * ic)
+{
+  sym_link *dtype;
+  symbol *albl = newiTempLabel (NULL);
+  symbol *blbl = newiTempLabel (NULL);
+  PIC_OPCODE poc;
+  pCodeOp *pcop;
+  operand *left;
+
+  FENTRY;
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  /* if caller saves & we have not saved then */
+  if (!ic->regsSaved)
+    saveRegisters (ic);
+
+  /* if we are calling a function that is not using
+     the same register bank then we need to save the
+     destination registers on the stack */
+  dtype = operandType (IC_LEFT (ic));
+  if (currFunc && dtype && IFFUNC_ISISR (currFunc->type) && (FUNC_REGBANK (currFunc->type) != FUNC_REGBANK (dtype)))
+    saverbank (FUNC_REGBANK (dtype), ic, TRUE);
+
+  left = IC_LEFT (ic);
+  aopOp (left, ic, FALSE);
+  DEBUGpic14_AopType (__LINE__, left, NULL, NULL);
+
+  poc = (op_isLitLike (IC_LEFT (ic)) ? POC_MOVLW : POC_MOVFW);
+
+  pushSide (IC_LEFT (ic), FARPTRSIZE);
+
+  /* if send set is not empty, assign parameters */
+  if (_G.sendSet)
+    {
+      DEBUGpic14_emitcode ("; ***", "%s  %d - WARNING arg-passing to indirect call not supported", __FUNCTION__, __LINE__);
+      /* no way to pass args - W always gets used to make the call */
+    }
+  /* first idea - factor out a common helper function and call it.
+     But don't know how to get it generated only once in its own block
+
+     if(AOP_TYPE(IC_LEFT(ic)) == AOP_DIR) {
+     char *rname;
+     char *buffer;
+     size_t len;
+
+     rname = IC_LEFT(ic)->aop->aopu.aop_dir;
+     DEBUGpic14_emitcode ("; ***","%s  %d AOP_DIR %s",__FUNCTION__,__LINE__,rname);
+     len = strlen(rname) + 16;
+     buffer = Safe_alloc(len);
+     SNPRINTF(buffer, len, "%s_goto_helper", rname);
+     addpCode2pBlock(pb,newpCode(POC_CALL,newpCodeOp(buffer,PO_STR)));
+     free(buffer);
+     }
+   */
+  emitpcode (POC_CALL, popGetLabel (albl->key));
+  pcop = popGetLabel (blbl->key);
+  emitpcode (POC_PAGESEL, pcop);        /* Must restore PCLATH before goto, without destroying W */
+  emitpcode (POC_GOTO, pcop);
+  emitpLabel (albl->key);
+
+  emitpcode (poc, popGetAddr (AOP (left), 1, 0));
+  emitpcode (POC_MOVWF, popCopyReg (&pc_pclath));
+  emitpcode (poc, popGetAddr (AOP (left), 0, 0));
+  emitpcode (POC_MOVWF, popCopyReg (&pc_pcl));
+
+  emitpLabel (blbl->key);
+
+  freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
+
+  /* if we need to assign a result value */
+  if ((IS_ITEMP (IC_RESULT (ic)) &&
+       (OP_SYMBOL (IC_RESULT (ic))->nRegs || OP_SYMBOL (IC_RESULT (ic))->spildir)) || IS_TRUE_SYMOP (IC_RESULT (ic)))
+    {
+
+      _G.accInUse++;
+      aopOp (IC_RESULT (ic), ic, FALSE);
+      _G.accInUse--;
+
+      GpseudoStkPtr = 0;
+
+      assignResultValue (IC_RESULT (ic));
+
+      freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+    }
+
+  /* if register bank was saved then unsave them */
+  if (currFunc && dtype && (FUNC_REGBANK (currFunc->type) != FUNC_REGBANK (dtype)))
+    unsaverbank (FUNC_REGBANK (dtype), ic, TRUE);
+
+  /* if we hade saved some registers then
+     unsave them */
+  if (ic->regsSaved)
+    unsaveRegisters (ic);
+}
+
+/*-----------------------------------------------------------------*/
+/* resultRemat - result  is rematerializable                       */
+/*-----------------------------------------------------------------*/
+static int
+resultRemat (iCode * ic)
+{
+  //  DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+  FENTRY;
+
+  if (SKIP_IC (ic) || ic->op == IFX)
+    return 0;
+
+  if (IC_RESULT (ic) && IS_ITEMP (IC_RESULT (ic)))
+    {
+      symbol *sym = OP_SYMBOL (IC_RESULT (ic));
+      if (sym->remat && !POINTER_SET (ic))
+        return 1;
+    }
+
+  return 0;
+}
+
+/*-----------------------------------------------------------------*/
+/* genFunction - generated code for function entry                 */
+/*-----------------------------------------------------------------*/
+static void
+genFunction (iCode * ic)
+{
+  symbol *sym;
+  sym_link *ftype;
+
+  FENTRY;
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d curr label offset=%dprevious max_key=%d ", __FUNCTION__, __LINE__, labelOffset,
+                       max_key);
+
+  labelOffset += (max_key + 4);
+  max_key = 0;
+  GpseudoStkPtr = 0;
+  _G.nRegsSaved = 0;
+  /* create the function header */
+  pic14_emitcode (";", "-----------------------------------------");
+  pic14_emitcode (";", " function %s", (sym = OP_SYMBOL (IC_LEFT (ic)))->name);
+  pic14_emitcode (";", "-----------------------------------------");
+
+  /* prevent this symbol from being emitted as 'extern' */
+  pic14_stringInSet (sym->rname, &pic14_localFunctions, 1);
+
+  pic14_emitcode ("", "%s:", sym->rname);
+  addpCode2pBlock (pb, newpCodeFunction (moduleName, sym->rname, !IS_STATIC (sym->etype), IFFUNC_ISISR (sym->type)));
+
+  /* mark symbol as NOT extern (even if it was declared so previously) */
+  assert (IS_SPEC (sym->etype));
+  SPEC_EXTR (sym->etype) = 0;
+  sym->cdef = 0;
+  if (!SPEC_OCLS (sym->etype))
+    SPEC_OCLS (sym->etype) = code;
+  addSetIfnotP (&SPEC_OCLS (sym->etype)->syms, sym);
+
+  ftype = operandType (IC_LEFT (ic));
+
+  /* here we need to generate the equates for the
+     register bank if required */
+#if 0
+  if (FUNC_REGBANK (ftype) != rbank)
+    {
+      int i;
+
+      rbank = FUNC_REGBANK (ftype);
+      for (i = 0; i < pic14_nRegs; i++)
+        {
+          if (strcmp (regspic14[i].base, "0") == 0)
+            pic14_emitcode ("", "%s = 0x%02x", regspic14[i].dname, 8 * rbank + regspic14[i].offset);
+          else
+            pic14_emitcode ("", "%s = %s + 0x%02x", regspic14[i].dname, regspic14[i].base, 8 * rbank + regspic14[i].offset);
+        }
+    }
+#endif
+
+  /* if this is an interrupt service routine */
+  pic14_inISR = 0;
+  if (IFFUNC_ISISR (sym->type))
+    {
+      pic14_inISR = 1;
+
+      /* generate ISR prolog if and not naked */
+      if (!IFFUNC_ISNAKED (sym->type))
+        {
+          if (pic->isEnhancedCore)
+            {
+              /*
+               * Enhanced CPUs have automatic context saving for W,
+               * STATUS, BSR, FSRx, and PCLATH in shadow registers.
+               */
+              emitpcode (POC_CLRF, popCopyReg (&pc_pclath));
+            }
+          else
+            {
+              emitpcode (POC_MOVWF, popCopyReg (&pc_wsave));
+              emitpcode (POC_SWAPFW, popCopyReg (&pc_status));
+              /* XXX: Why? Does this assume that ssave and psave reside
+               * in a shared bank or bank0? We cannot guarantee the
+               * latter...
+               */
+              emitpcode (POC_CLRF, popCopyReg (&pc_status));
+              emitpcode (POC_MOVWF, popCopyReg (&pc_ssave));
+              //emitpcode(POC_MOVWF,  popGetExternal("___sdcc_saved_status",1 ));
+              emitpcode (POC_MOVFW, popCopyReg (&pc_pclath));
+              /* during an interrupt PCLATH must be cleared before a goto or call statement */
+              emitpcode (POC_CLRF, popCopyReg (&pc_pclath));
+              emitpcode (POC_MOVWF, popCopyReg (&pc_psave));
+              //emitpcode(POC_MOVWF,  popGetExternal("___sdcc_saved_pclath", 1));
+              emitpcode (POC_MOVFW, popCopyReg (&pc_fsr));
+              emitpcode (POC_MOVWF, popGetExternal ("___sdcc_saved_fsr", 1));
+            }
+        }
+
+      pBlockConvert2ISR (pb);
+      pic14_hasInterrupt = 1;
+    }
+  else
+    {
+      /* if callee-save to be used for this function
+         then save the registers being used in this function */
+      if (IFFUNC_CALLEESAVES (sym->type))
+        {
+          int i;
+
+          /* if any registers used */
+          if (sym->regsUsed)
+            {
+              /* save the registers used */
+              for (i = 0; i < sym->regsUsed->size; i++)
+                {
+                  if (bitVectBitValue (sym->regsUsed, i))
+                    {
+                      //pic14_emitcode("push","%s",pic14_regWithIdx(i)->dname);
+                      _G.nRegsSaved++;
+                    }
+                }
+            }
+        }
+    }
+
+  /* if critical function then turn interrupts off */
+  if (IFFUNC_ISCRITICAL (ftype))
+    {
+      genCritical (NULL);
+      if (IFFUNC_ARGS (sym->type))
+        {
+          fprintf (stderr, "PIC14: Functions with __critical (%s) must not have arguments for now.\n", sym->name);
+          exit (1);
+        }                       // if
+    }                           // if
+
+  /* set the register bank to the desired value */
+  if (FUNC_REGBANK (sym->type) || FUNC_ISISR (sym->type))
+    {
+      pic14_emitcode ("push", "psw");
+      pic14_emitcode ("mov", "psw,#0x%02x", (FUNC_REGBANK (sym->type) << 3) & 0x00ff);
+    }
+
+  if (IFFUNC_ISREENT (sym->type) || options.stackAuto)
+    {
+
+      if (options.useXstack)
+        {
+          pic14_emitcode ("mov", "r0,%s", spname);
+          pic14_emitcode ("mov", "a,_bp");
+          pic14_emitcode ("movx", "@r0,a");
+          pic14_emitcode ("inc", "%s", spname);
+        }
+      else
+        {
+          /* set up the stack */
+          pic14_emitcode ("push", "_bp");       /* save the callers stack  */
+        }
+      pic14_emitcode ("mov", "_bp,%s", spname);
+    }
+
+  /* adjust the stack for the function */
+  if (sym->stack)
+    {
+
+      int i = sym->stack;
+      if (i > 256)
+        werror (W_STACK_OVERFLOW, sym->name);
+
+      if (i > 3 && sym->recvSize < 4)
+        {
+
+          pic14_emitcode ("mov", "a,sp");
+          pic14_emitcode ("add", "a,#0x%02x", ((char) sym->stack & 0xff));
+          pic14_emitcode ("mov", "sp,a");
+
+        }
+      else
+        while (i--)
+          pic14_emitcode ("inc", "sp");
+    }
+
+  if (sym->xstack)
+    {
+
+      pic14_emitcode ("mov", "a,_spx");
+      pic14_emitcode ("add", "a,#0x%02x", ((char) sym->xstack & 0xff));
+      pic14_emitcode ("mov", "_spx,a");
+    }
+
+}
+
+/*-----------------------------------------------------------------*/
+/* genEndFunction - generates epilogue for functions               */
+/*-----------------------------------------------------------------*/
+static void
+genEndFunction (iCode * ic)
+{
+  symbol *sym = OP_SYMBOL (IC_LEFT (ic));
+
+  FENTRY;
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+  if (IFFUNC_ISREENT (sym->type) || options.stackAuto)
+    {
+      pic14_emitcode ("mov", "%s,_bp", spname);
+    }
+
+  /* if use external stack but some variables were
+     added to the local stack then decrement the
+     local stack */
+  if (options.useXstack && sym->stack)
+    {
+      pic14_emitcode ("mov", "a,sp");
+      pic14_emitcode ("add", "a,#0x%02x", ((char) - sym->stack) & 0xff);
+      pic14_emitcode ("mov", "sp,a");
+    }
+
+
+  if ((IFFUNC_ISREENT (sym->type) || options.stackAuto))
+    {
+      if (options.useXstack)
+        {
+          pic14_emitcode ("mov", "r0,%s", spname);
+          pic14_emitcode ("movx", "a,@r0");
+          pic14_emitcode ("mov", "_bp,a");
+          pic14_emitcode ("dec", "%s", spname);
+        }
+      else
+        {
+          pic14_emitcode ("pop", "_bp");
+        }
+    }
+
+  /* restore the register bank    */
+  if (FUNC_REGBANK (sym->type) || FUNC_ISISR (sym->type))
+    pic14_emitcode ("pop", "psw");
+
+  /* if critical function then turn interrupts off */
+  if (IFFUNC_ISCRITICAL (sym->type))
+    {
+      genEndCritical (NULL);
+    }                           // if
+
+  if (IFFUNC_ISISR (sym->type))
+    {
+
+      /* now we need to restore the registers */
+      /* if this isr has no bank i.e. is going to
+         run with bank 0 , then we need to save more
+         registers :-) */
+      if (!FUNC_REGBANK (sym->type))
+        {
+
+          /* if this function does not call any other
+             function then we can be economical and
+             save only those registers that are used */
+          if (!IFFUNC_HASFCALL (sym->type))
+            {
+              int i;
+
+              /* if any registers used */
+              if (sym->regsUsed)
+                {
+                  /* save the registers used */
+                  for (i = sym->regsUsed->size; i >= 0; i--)
+                    {
+                      if (bitVectBitValue (sym->regsUsed, i))
+                        {
+                          pic14_emitcode ("pop", "junk");       //"%s",pic14_regWithIdx(i)->dname);
+                        }
+                    }
+                }
+
+            }
+          else
+            {
+              /* this function has a function call; cannot
+                 determines register usage so we will have the
+                 entire bank */
+              unsaverbank (0, ic, FALSE);
+            }
+        }
+
+      /* if debug then send end of function */
+      if (options.debug && debugFile && currFunc)
+        {
+          debugFile->writeEndFunction (currFunc, ic, 1);
+        }
+
+      /* generate ISR epilog if not enhanced core and not naked */
+      if (!pic->isEnhancedCore && !IFFUNC_ISNAKED (sym->type))
+        {
+          emitpcode (POC_MOVFW, popGetExternal ("___sdcc_saved_fsr", 1));
+          emitpcode (POC_MOVWF, popCopyReg (&pc_fsr));
+          //emitpcode(POC_MOVFW,  popGetExternal("___sdcc_saved_pclath", 1));
+          emitpcode (POC_MOVFW, popCopyReg (&pc_psave));
+          emitpcode (POC_MOVWF, popCopyReg (&pc_pclath));
+          emitpcode (POC_CLRF, popCopyReg (&pc_status));        // see genFunction
+          //emitpcode(POC_SWAPFW, popGetExternal("___sdcc_saved_status", 1));
+          emitpcode (POC_SWAPFW, popCopyReg (&pc_ssave));
+          emitpcode (POC_MOVWF, popCopyReg (&pc_status));
+          emitpcode (POC_SWAPF, popCopyReg (&pc_wsave));
+          emitpcode (POC_SWAPFW, popCopyReg (&pc_wsave));
+        }
+      addpCode2pBlock (pb, newpCodeLabel ("END_OF_INTERRUPT", -1));
+      emitpcodeNULLop (POC_RETFIE);
+    }
+  else
+    {
+      if (IFFUNC_ISCRITICAL (sym->type))
+        pic14_emitcode ("setb", "ea");
+
+      if (IFFUNC_CALLEESAVES (sym->type))
+        {
+          int i;
+
+          /* if any registers used */
+          if (sym->regsUsed)
+            {
+              /* save the registers used */
+              for (i = sym->regsUsed->size; i >= 0; i--)
+                {
+                  if (bitVectBitValue (sym->regsUsed, i))
+                    {
+                      pic14_emitcode ("pop", "junk");   //"%s",pic14_regWithIdx(i)->dname);
+                    }
+                }
+            }
+        }
+
+      /* if debug then send end of function */
+      if (options.debug && debugFile && currFunc)
+        {
+          debugFile->writeEndFunction (currFunc, ic, 1);
+        }
+
+      pic14_emitcode ("return", "");
+      emitpcodeNULLop (POC_RETURN);
+
+      /* Mark the end of a function */
+      addpCode2pBlock (pb, newpCodeFunction (moduleName, NULL, 0, 0));
+    }
+
+}
+
+/*-----------------------------------------------------------------*/
+/* genRet - generate code for return statement                     */
+/*-----------------------------------------------------------------*/
+static void
+genRet (iCode * ic)
+{
+  int size, offset = 0;
+
+  FENTRY;
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  /* if we have no return value then
+     just generate the "ret" */
+  if (!IC_LEFT (ic))
+    goto jumpret;
+
+  /* we have something to return then
+     move the return value into place */
+  aopOp (IC_LEFT (ic), ic, FALSE);
+  size = AOP_SIZE (IC_LEFT (ic));
+
+  for (offset = 0; offset < size; offset++)
+    {
+      pass_argument (IC_LEFT (ic), offset, size - 1 - offset);
+    }
+
+  freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
+
+jumpret:
+  /* generate a jump to the return label
+     if the next is not the return statement */
+  if (!(ic->next && ic->next->op == LABEL && IC_LABEL (ic->next) == returnLabel))
+    {
+
+      emitpcode (POC_GOTO, popGetLabel (returnLabel->key));
+    }
+
+}
+
+static set *critical_temps = NULL;
+
+static void
+genCritical (iCode * ic)
+{
+  pCodeOp *saved_intcon;
+
+  (void) ic;
+
+  if (!critical_temps)
+    critical_temps = newSet ();
+
+  saved_intcon = popGetTempReg ();
+  addSetHead (&critical_temps, saved_intcon);
+
+  /* This order saves one BANKSEL back to INTCON. */
+  emitpcode (POC_MOVFW, popCopyReg (&pc_intcon));
+  emitpcode (POC_BCF, popCopyGPR2Bit (popCopyReg (&pc_intcon), 7));
+  emitpcode (POC_MOVWF, pCodeOpCopy (saved_intcon));
+}
+
+static void
+genEndCritical (iCode * ic)
+{
+  pCodeOp *saved_intcon = NULL;
+
+  (void) ic;
+
+  saved_intcon = getSet (&critical_temps);
+  if (!saved_intcon)
+    {
+      fprintf (stderr, "Critical section left, but none entered -- ignoring for now.\n");
+      return;
+    }                           // if
+
+  emitpcode (POC_BTFSC, popCopyGPR2Bit (pCodeOpCopy (saved_intcon), 7));
+  emitpcode (POC_BSF, popCopyGPR2Bit (popCopyReg (&pc_intcon), 7));
+  popReleaseTempReg (saved_intcon);
+}
+
+/*-----------------------------------------------------------------*/
+/* genLabel - generates a label                                    */
+/*-----------------------------------------------------------------*/
+static void
+genLabel (iCode * ic)
+{
+  FENTRY;
+
+  /* special case never generate */
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  if (IC_LABEL (ic) == entryLabel)
+    return;
+
+  emitpLabel (IC_LABEL (ic)->key);
+  pic14_emitcode ("", "_%05d_DS_:", labelKey2num (IC_LABEL (ic)->key + labelOffset));
+}
+
+/*-----------------------------------------------------------------*/
+/* genGoto - generates a goto                                      */
+/*-----------------------------------------------------------------*/
+//tsd
+static void
+genGoto (iCode * ic)
+{
+  FENTRY;
+
+  emitpcode (POC_GOTO, popGetLabel (IC_LABEL (ic)->key));
+  pic14_emitcode ("goto", "_%05d_DS_", labelKey2num (IC_LABEL (ic)->key + labelOffset));
+}
+
+
+/*-----------------------------------------------------------------*/
+/* genMultbits :- multiplication of bits                           */
+/*-----------------------------------------------------------------*/
+static void
+genMultbits (operand * left, operand * right, operand * result)
+{
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+  if (!pic14_sameRegs (AOP (result), AOP (right)))
+    emitpcode (POC_BSF, popGet (AOP (result), 0));
+
+  emitpcode (POC_BTFSC, popGet (AOP (right), 0));
+  emitpcode (POC_BTFSS, popGet (AOP (left), 0));
+  emitpcode (POC_BCF, popGet (AOP (result), 0));
+
+}
+
+
+/*-----------------------------------------------------------------*/
+/* genMultOneByte : 8 bit multiplication & division                */
+/*-----------------------------------------------------------------*/
+static void
+genMultOneByte (operand * left, operand * right, operand * result)
+{
+  char *func[] = { NULL, "__mulchar", "__mulint", NULL, "__mullong" };
+
+  // symbol *lbl ;
+  int size, offset, i;
+
+
+  FENTRY;
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  DEBUGpic14_AopType (__LINE__, left, right, result);
+  DEBUGpic14_AopTypeSign (__LINE__, left, right, result);
+
+  /* (if two literals, the value is computed before) */
+  /* if one literal, literal on the right */
+  if (AOP_TYPE (left) == AOP_LIT)
+    {
+      operand *t = right;
+      right = left;
+      left = t;
+    }
+
+  assert (AOP_SIZE (left) == AOP_SIZE (right));
+
+  size = min (AOP_SIZE (result), AOP_SIZE (left));
+  offset = Gstack_base_addr - (2 * size - 1);
+
+  /* pass right operand as argument */
+  for (i = 0; i < size; i++)
+    {
+      mov2w (AOP (right), i);
+      emitpcode (POC_MOVWF, popRegFromIdx (++offset));
+    }                           // for
+
+  /* pass left operand as argument */
+  for (i = 0; i < size; i++)
+    {
+      mov2w (AOP (left), i);
+      if (i != size - 1)
+        emitpcode (POC_MOVWF, popRegFromIdx (++offset));
+    }                           // for
+  assert (offset == Gstack_base_addr);
+
+  /* call library routine */
+  assert (size > 0 && size <= 4);
+  call_libraryfunc (func[size]);
+
+  /* assign result */
+  movwf (AOP (result), size - 1);
+  for (i = 0; i < size - 1; i++)
+    {
+      emitpcode (POC_MOVFW, popRegFromIdx (Gstack_base_addr - i));
+      movwf (AOP (result), size - 2 - i);
+    }                           // for
+
+  /* now (zero-/sign) extend the result to its size */
+  addSign (result, AOP_SIZE (left), !SPEC_USIGN (operandType (result)));
+}
+
+/*-----------------------------------------------------------------*/
+/* genMult - generates code for multiplication                     */
+/*-----------------------------------------------------------------*/
+static void
+genMult (iCode * ic)
+{
+  operand *left = IC_LEFT (ic);
+  operand *right = IC_RIGHT (ic);
+  operand *result = IC_RESULT (ic);
+
+  FENTRY;
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  /* assign the amsops */
+  aopOp (left, ic, FALSE);
+  aopOp (right, ic, FALSE);
+  aopOp (result, ic, TRUE);
+
+  DEBUGpic14_AopType (__LINE__, left, right, result);
+
+  /* special cases first */
+  /* both are bits */
+  if (AOP_TYPE (left) == AOP_CRY && AOP_TYPE (right) == AOP_CRY)
+    {
+      genMultbits (left, right, result);
+      goto release;
+    }
+
+  /* if both are of size == 1 */
+  if (AOP_SIZE (left) == 1 && AOP_SIZE (right) == 1)
+    {
+      genMultOneByte (left, right, result);
+      goto release;
+    }
+
+  /* should have been converted to function call */
+  assert (0);
+
+release:
+  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (result, NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genDivbits :- division of bits                                  */
+/*-----------------------------------------------------------------*/
+static void
+genDivbits (operand * left, operand * right, operand * result)
+{
+
+  char *l;
+
+  FENTRY;
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  /* the result must be bit */
+  pic14_emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE));
+  l = aopGet (AOP (left), 0, FALSE, FALSE);
+
+  MOVA (l);
+
+  pic14_emitcode ("div", "ab");
+  pic14_emitcode ("rrc", "a");
+  aopPut (AOP (result), "c", 0);
+}
+
+/*-----------------------------------------------------------------*/
+/* genDivOneByte : 8 bit division                                  */
+/*-----------------------------------------------------------------*/
+static void
+genDivOneByte (operand * left, operand * right, operand * result)
+{
+  int sign;
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+  assert (AOP_SIZE (right) == 1);
+  assert (AOP_SIZE (left) == 1);
+
+  sign = !(SPEC_USIGN (operandType (left)) && SPEC_USIGN (operandType (right)));
+
+  if (AOP_TYPE (right) == AOP_LIT)
+    {
+      /* XXX: might add specialized code */
+    }
+
+  if (!sign)
+    {
+      /* unsigned division */
+#if 1
+      mov2w (AOP (right), 0);
+      emitpcode (POC_MOVWF, popRegFromIdx (Gstack_base_addr));
+      mov2w (AOP (left), 0);
+      call_libraryfunc ("__divuchar");
+      movwf (AOP (result), 0);
+#else
+      pCodeOp *temp;
+      symbol *lbl;
+
+      temp = popGetTempReg ();
+      lbl = newiTempLabel (NULL);
+
+      /* XXX: improve this naive approach:
+         [result] = [a] / [b]
+         ::= [result] = 0; while ([a] > [b]) do [a] -= [b]; [result]++ done
+
+         In PIC assembler:
+         movf  left,W
+         movwf temp       // temp <-- left
+         movf  right,W    // W <-- right
+         clrf  result
+         label1:
+         incf  result
+         subwf temp,F     // temp <-- temp - W
+         skipNC       // subwf clears CARRY (i.e. sets BORROW) if temp < W
+         goto  label1
+         decf result      // we just subtract once too often
+       */
+
+      /* XXX: This loops endlessly on DIVIDE BY ZERO */
+      /* We need 1..128 iterations of the loop body (`4 / 5' .. `255 / 2'). */
+
+      mov2w (AOP (left), 0);
+      emitpcode (POC_MOVWF, temp);
+      mov2w (AOP (right), 0);
+      emitpcode (POC_CLRF, popGet (AOP (result), 0));
+
+      emitpLabel (lbl->key);
+      emitpcode (POC_INCF, popGet (AOP (result), 0));
+      emitpcode (POC_SUBWF, temp);
+      emitSKPNC;
+
+      if (pic->isEnhancedCore)
+        {
+          emitpcode (POC_BRA, popGetLabel (lbl->key));
+        }
+      else
+        {
+          emitpcode (POC_GOTO, popGetLabel (lbl->key));
+        }
+
+      emitpcode (POC_DECF, popGet (AOP (result), 0));
+      popReleaseTempReg (temp);
+#endif
+    }
+  else
+    {
+      /* signed division */
+      mov2w (AOP (right), 0);
+      emitpcode (POC_MOVWF, popRegFromIdx (Gstack_base_addr));
+      mov2w (AOP (left), 0);
+      call_libraryfunc ("__divschar");
+      movwf (AOP (result), 0);
+    }
+
+  /* now performed the signed/unsigned division -- extend result */
+  addSign (result, 1, sign);
+}
+
+/*-----------------------------------------------------------------*/
+/* genDiv - generates code for division                */
+/*-----------------------------------------------------------------*/
+static void
+genDiv (iCode * ic)
+{
+  operand *left = IC_LEFT (ic);
+  operand *right = IC_RIGHT (ic);
+  operand *result = IC_RESULT (ic);
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  /* assign the amsops */
+  aopOp (left, ic, FALSE);
+  aopOp (right, ic, FALSE);
+  aopOp (result, ic, TRUE);
+
+  /* special cases first */
+  /* both are bits */
+  if (AOP_TYPE (left) == AOP_CRY && AOP_TYPE (right) == AOP_CRY)
+    {
+      genDivbits (left, right, result);
+      goto release;
+    }
+
+  /* if both are of size == 1 */
+  if (AOP_SIZE (left) == 1 && AOP_SIZE (right) == 1)
+    {
+      genDivOneByte (left, right, result);
+      goto release;
+    }
+
+  /* should have been converted to function call */
+  assert (0);
+release:
+  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (result, NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genModOneByte : 8 bit modulus                                   */
+/*-----------------------------------------------------------------*/
+static void
+genModOneByte (operand * left, operand * right, operand * result)
+{
+  int sign;
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+  assert (AOP_SIZE (right) == 1);
+  assert (AOP_SIZE (left) == 1);
+
+  sign = !(SPEC_USIGN (operandType (left)) && SPEC_USIGN (operandType (right)));
+
+  if (AOP_TYPE (right) == AOP_LIT)
+    {
+      /* XXX: might add specialized code */
+    }
+
+  if (!sign)
+    {
+      /* unsigned division */
+#if 1
+      mov2w (AOP (right), 0);
+      emitpcode (POC_MOVWF, popRegFromIdx (Gstack_base_addr));
+      mov2w (AOP (left), 0);
+      call_libraryfunc ("__moduchar");
+      movwf (AOP (result), 0);
+#else
+      pCodeOp *temp;
+      symbol *lbl;
+
+      lbl = newiTempLabel (NULL);
+
+      assert (!pic14_sameRegs (AOP (right), AOP (result)));
+
+      /* XXX: improve this naive approach:
+         [result] = [a] % [b]
+         ::= [result] = [a]; while ([result] > [b]) do [result] -= [b]; done
+
+         In PIC assembler:
+         movf  left,W
+         movwf result     // result <-- left
+         movf  right,W    // W <-- right
+         label1:
+         subwf result,F   // result <-- result - W
+         skipNC       // subwf clears CARRY (i.e. sets BORROW) if result < W
+         goto  label1
+         addwf result, F  // we just subtract once too often
+       */
+
+      /* XXX: This loops endlessly on DIVIDE BY ZERO */
+      /* We need 1..128 iterations of the loop body (`4 % 5' .. `255 % 2'). */
+
+      if (!pic14_sameRegs (AOP (left), AOP (result)))
+        {
+          mov2w (AOP (left), 0);
+          emitpcode (POC_MOVWF, popGet (AOP (result), 0));
+        }
+      mov2w (AOP (right), 0);
+
+      emitpLabel (lbl->key);
+      emitpcode (POC_SUBWF, popGet (AOP (result), 0));
+      emitSKPNC;
+
+      if (pic->isEnhancedCore)
+        {
+          emitpcode (POC_BRA, popGetLabel (lbl->key));
+        }
+      else
+        {
+          emitpcode (POC_GOTO, popGetLabel (lbl->key));
+        }
+
+      emitpcode (POC_ADDWF, popGet (AOP (result), 0));
+#endif
+    }
+  else
+    {
+      /* signed division */
+      mov2w (AOP (right), 0);
+      emitpcode (POC_MOVWF, popRegFromIdx (Gstack_base_addr));
+      mov2w (AOP (left), 0);
+      call_libraryfunc ("__modschar");
+      movwf (AOP (result), 0);
+    }
+
+  /* now we performed the signed/unsigned modulus -- extend result */
+  addSign (result, 1, sign);
+}
+
+/*-----------------------------------------------------------------*/
+/* genMod - generates code for division                            */
+/*-----------------------------------------------------------------*/
+static void
+genMod (iCode * ic)
+{
+  operand *left = IC_LEFT (ic);
+  operand *right = IC_RIGHT (ic);
+  operand *result = IC_RESULT (ic);
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  /* assign the amsops */
+  aopOp (left, ic, FALSE);
+  aopOp (right, ic, FALSE);
+  aopOp (result, ic, TRUE);
+
+  /* if both are of size == 1 */
+  if (AOP_SIZE (left) == 1 && AOP_SIZE (right) == 1)
+    {
+      genModOneByte (left, right, result);
+      goto release;
+    }
+
+  /* should have been converted to function call */
+  assert (0);
+
+release:
+  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (result, NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genIfxJump :- will create a jump depending on the ifx           */
+/*-----------------------------------------------------------------*/
+/*
+note: May need to add parameter to indicate when a variable is in bit space.
+*/
+static void
+genIfxJump (iCode * ic, char *jval)
+{
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  /* if true label then we jump if condition
+     supplied is true */
+  if (IC_TRUE (ic))
+    {
+
+      if (strcmp (jval, "a") == 0)
+        emitSKPZ;
+      else if (strcmp (jval, "c") == 0)
+        emitSKPC;
+      else
+        {
+          DEBUGpic14_emitcode ("; ***", "%d - assuming %s is in bit space", __LINE__, jval);
+          emitpcode (POC_BTFSC, newpCodeOpBit (jval, -1, 1));
+        }
+
+      emitpcode (POC_GOTO, popGetLabel (IC_TRUE (ic)->key));
+      pic14_emitcode (" goto", "_%05d_DS_", labelKey2num (IC_TRUE (ic)->key + labelOffset));
+
+    }
+  else
+    {
+      /* false label is present */
+      if (strcmp (jval, "a") == 0)
+        emitSKPNZ;
+      else if (strcmp (jval, "c") == 0)
+        emitSKPNC;
+      else
+        {
+          DEBUGpic14_emitcode ("; ***", "%d - assuming %s is in bit space", __LINE__, jval);
+          emitpcode (POC_BTFSS, newpCodeOpBit (jval, -1, 1));
+        }
+
+      emitpcode (POC_GOTO, popGetLabel (IC_FALSE (ic)->key));
+      pic14_emitcode (" goto", "_%05d_DS_", labelKey2num (IC_FALSE (ic)->key + labelOffset));
+
+    }
+
+
+  /* mark the icode as generated */
+  ic->generated = TRUE;
+}
+
+/*-----------------------------------------------------------------*/
+/* genSkipc                                                        */
+/*-----------------------------------------------------------------*/
+static void
+genSkipc (resolvedIfx * rifx)
+{
+  FENTRY;
+  if (!rifx)
+    return;
+
+  if (rifx->condition)
+    emitSKPNC;
+  else
+    emitSKPC;
+
+  emitpcode (POC_GOTO, popGetLabel (rifx->lbl->key));
+  emitpComment ("%s:%u: created from rifx:%p", __FUNCTION__, __LINE__, rifx);
+  rifx->generated = TRUE;
+}
+
+#define isAOP_REGlike(x)  (AOP_TYPE(x) == AOP_REG || AOP_TYPE(x) == AOP_DIR || AOP_TYPE(x) == AOP_PCODE)
+#define isAOP_LIT(x)      (AOP_TYPE(x) == AOP_LIT)
+#define DEBUGpc           emitpComment
+
+/*-----------------------------------------------------------------*/
+/* mov2w_regOrLit :- move to WREG either the offset's byte from    */
+/*                  aop (if it's NOT a literal) or from lit (if    */
+/*                  aop is a literal)                              */
+/*-----------------------------------------------------------------*/
+static void
+pic14_mov2w_regOrLit (asmop * aop, unsigned long lit, int offset)
+{
+  if (aop->type == AOP_LIT)
+    {
+      emitpcode (POC_MOVLW, popGetLit ((lit >> (offset * 8)) & 0x00FF));
+    }
+  else
+    {
+      emitpcode (POC_MOVFW, popGet (aop, offset));
+    }
+}
+
+/* genCmp performs a left < right comparison, stores
+ * the outcome in result (if != NULL) and generates
+ * control flow code for the ifx (if != NULL).
+ *
+ * This version leaves in sequences like
+ * "B[CS]F STATUS,0; BTFS[CS] STATUS,0"
+ * which should be optmized by the peephole
+ * optimizer - RN 2005-01-01 */
+static void
+genCmp (operand * left, operand * right, operand * result, iCode * ifx, int sign)
+{
+  resolvedIfx rIfx;
+  int size;
+  int offs;
+  symbol *templbl;
+  operand *dummy;
+  unsigned long lit;
+  unsigned long mask;
+  int performedLt;
+  int invert_result = 0;
+
+  FENTRY;
+
+  assert (AOP_SIZE (left) == AOP_SIZE (right));
+  assert (left && right);
+
+  size = AOP_SIZE (right) - 1;
+  mask = (0x100UL << (size * 8)) - 1;
+  // in the end CARRY holds "left < right" (performedLt == 1) or "left >= right" (performedLt == 0)
+  performedLt = 1;
+  templbl = NULL;
+  lit = 0;
+
+  resolveIfx (&rIfx, ifx);
+
+  /**********************************************************************
+   * handle bits - bit compares are promoted to int compares seemingly! *
+   **********************************************************************/
+#if 0
+  // THIS IS COMPLETELY UNTESTED!
+  if (AOP_TYPE (left) == AOP_CRY && AOP_TYPE (right) == AOP_CRY)
+    {
+      pCodeOp *pcleft = pic16_popGet (AOP (left), 0);
+      pCodeOp *pcright = pic16_popGet (AOP (right), 0);
+      assert (pcleft->type == PO_GPR_BIT && pcright->type == PO_GPR_BIT);
+
+      emitSETC;
+      // 1 < {0,1} is false --> clear C by skipping the next instruction
+      //pic16_emitpcode (POC_BTFSS, pic16_popCopyGPR2Bit (AOP (left),0), PCORB (pcleft)->bit);
+      pic16_emitpcode (POC_BTFSS, pic16_popGet (AOP (left), 0));
+      // {0,1} < 0 is false --> clear C by NOT skipping the next instruction
+      pic16_emitpcode (POC_BTFSS, pic16_popCopyGPR2Bit (pic16_popGet (AOP (right), 0), PCORB (pcright)->bit));
+      emitCLRC;                 // only skipped for left=0 && right=1
+
+      goto correct_result_in_carry;
+    }                           // if
+#endif
+
+  /*************************************************
+   * make sure that left is register (or the like) *
+   *************************************************/
+  if (!isAOP_REGlike (left))
+    {
+      DEBUGpc ("swapping arguments (AOP_TYPEs %d/%d)", AOP_TYPE (left), AOP_TYPE (right));
+      assert (isAOP_LIT (left));
+      assert (isAOP_REGlike (right));
+      // swap left and right
+      // left < right <==> right > left <==> (right >= left + 1)
+      lit = ulFromVal (AOP (left)->aopu.aop_lit);
+
+      if ((!sign && (lit & mask) == mask) || (sign && (lit & mask) == (mask >> 1)))
+        {
+          // MAXVALUE < right? always false
+          if (performedLt)
+            emitCLRC;
+          else
+            emitSETC;
+          goto correct_result_in_carry;
+        }                       // if
+
+      // This fails for lit = 0xFF (unsigned) AND lit = 0x7F (signed),
+      // that's why we handled it above.
+      lit++;
+
+      dummy = left;
+      left = right;
+      right = dummy;
+
+      performedLt ^= 1;         // instead of "left < right" we check for "right >= left+1, i.e. "right < left+1"
+    }
+  else if (isAOP_LIT (right))
+    {
+      lit = ulFromVal (AOP (right)->aopu.aop_lit);
+    }                           // if
+
+  assert (isAOP_REGlike (left));        // left must be register or the like
+  assert (isAOP_REGlike (right) || isAOP_LIT (right));  // right may be register-like or a literal
+
+  /*************************************************
+   * special cases go here                         *
+   *************************************************/
+
+  if (isAOP_LIT (right))
+    {
+      if (!sign)
+        {
+          // unsigned comparison to a literal
+          DEBUGpc ("unsigned compare: left %s lit(0x%X=%lu), size=%d", performedLt ? "<" : ">=", lit, lit, size + 1);
+          if (lit == 0)
+            {
+              // unsigned left < 0? always false
+              if (performedLt)
+                emitCLRC;
+              else
+                emitSETC;
+              goto correct_result_in_carry;
+            }
+        }
+      else
+        {
+          // signed comparison to a literal
+          DEBUGpc ("signed compare: left %s lit(0x%X=%ld), size=%d, mask=%x", performedLt ? "<" : ">=", lit, lit, size + 1,
+                   mask);
+          if ((lit & mask) == ((0x80 << (size * 8)) & mask))
+            {
+              // signed left < 0x80000000? always false
+              if (performedLt)
+                emitCLRC;
+              else
+                emitSETC;
+              goto correct_result_in_carry;
+            }
+          else if (lit == 0)
+            {
+              // compare left < 0; set CARRY if SIGNBIT(left) is set
+              if (performedLt)
+                emitSETC;
+              else
+                emitCLRC;
+              emitpcode (POC_BTFSS, newpCodeOpBit (aopGet (AOP (left), size, FALSE, FALSE), 7, 0));
+              if (performedLt)
+                emitCLRC;
+              else
+                emitSETC;
+              goto correct_result_in_carry;
+            }
+        }                       // if (!sign)
+    }                           // right is literal
+
+  /*************************************************
+   * perform a general case comparison             *
+   * make sure we get CARRY==1 <==> left >= right  *
+   *************************************************/
+  // compare most significant bytes
+  //DEBUGpc ("comparing bytes at offset %d", size);
+  if (!sign)
+    {
+      // unsigned comparison
+      pic14_mov2w_regOrLit (AOP (right), lit, size);
+      emitpcode (POC_SUBFW, popGet (AOP (left), size));
+    }
+  else
+    {
+      // signed comparison
+      // (add 2^n to both operands then perform an unsigned comparison)
+      if (isAOP_LIT (right))
+        {
+          // left >= LIT <-> LIT-left <= 0 <-> LIT-left == 0 OR !(LIT-left >= 0)
+          unsigned char litbyte = (lit >> (8 * size)) & 0xFF;
+
+          if (litbyte == 0x80)
+            {
+              // left >= 0x80 -- always true, but more bytes to come
+              mov2w (AOP (left), size);
+              emitpcode (POC_XORLW, popGetLit (0x80));  // set ZERO flag
+              emitSETC;
+            }
+          else
+            {
+              // left >= LIT <-> left + (-LIT) >= 0 <-> left + (0x100-LIT) >= 0x100
+              mov2w (AOP (left), size);
+              emitpcode (POC_ADDLW, popGetLit (0x80));
+              emitpcode (POC_ADDLW, popGetLit ((0x100 - (litbyte + 0x80)) & 0x00FF));
+            }                   // if
+        }
+      else
+        {
+          pCodeOp *pctemp = popGetTempReg ();
+          mov2w (AOP (left), size);
+          emitpcode (POC_ADDLW, popGetLit (0x80));
+          emitpcode (POC_MOVWF, pctemp);
+          mov2w (AOP (right), size);
+          emitpcode (POC_ADDLW, popGetLit (0x80));
+          emitpcode (POC_SUBFW, pctemp);
+          popReleaseTempReg (pctemp);
+        }
+    }                           // if (!sign)
+
+  // compare remaining bytes (treat as unsigned case from above)
+  templbl = newiTempLabel (NULL);
+  offs = size;
+  while (offs--)
+    {
+      //DEBUGpc ("comparing bytes at offset %d", offs);
+      emitSKPZ;
+
+      if (pic->isEnhancedCore)
+        {
+          emitpcode (POC_BRA, popGetLabel (templbl->key));
+        }
+      else
+        {
+          emitpcode (POC_GOTO, popGetLabel (templbl->key));
+        }
+
+      pic14_mov2w_regOrLit (AOP (right), lit, offs);
+      emitpcode (POC_SUBFW, popGet (AOP (left), offs));
+    }                           // while (offs)
+  emitpLabel (templbl->key);
+  goto result_in_carry;
+
+result_in_carry:
+
+  /****************************************************
+   * now CARRY contains the result of the comparison: *
+   * SUBWF sets CARRY iff                             *
+   * F-W >= 0 <==> F >= W <==> !(F < W)               *
+   * (F=left, W=right)                                *
+   ****************************************************/
+
+  if (performedLt)
+    {
+      invert_result = 1;
+      // value will be used in the following genSkipc ()
+      rIfx.condition ^= TRUE;
+    }                           // if
+
+correct_result_in_carry:
+
+  // assign result to variable (if neccessary), but keep CARRY intact to be used below
+  if (result && AOP_TYPE (result) != AOP_CRY)
+    {
+      //DEBUGpc ("assign result");
+      size = AOP_SIZE (result);
+      while (size--)
+        {
+          emitpcode (POC_CLRF, popGet (AOP (result), size));
+        }                       // while
+      if (invert_result)
+        {
+          emitSKPC;
+          emitpcode (POC_BSF, newpCodeOpBit (aopGet (AOP (result), 0, FALSE, FALSE), 0, 0));
+        }
+      else
+        {
+          emitpcode (POC_RLF, popGet (AOP (result), 0));
+          if (ifx)
+            {
+              /* Result is expected to be in CARRY by genSkipc () below. */
+              emitpcode (POC_RRFW, popGet (AOP (result), 0));
+            }                   // if
+        }                       // if
+    }                           // if (result)
+
+  // perform conditional jump
+  if (ifx)
+    {
+      //DEBUGpc ("generate control flow");
+      genSkipc (&rIfx);
+      ifx->generated = TRUE;
+    }                           // if
+}
+
+/*-----------------------------------------------------------------*/
+/* genCmpGt :- greater than comparison                             */
+/*-----------------------------------------------------------------*/
+static void
+genCmpGt (iCode * ic, iCode * ifx)
+{
+  operand *left, *right, *result;
+  sym_link *letype, *retype;
+  int sign;
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  left = IC_LEFT (ic);
+  right = IC_RIGHT (ic);
+  result = IC_RESULT (ic);
+
+  sign = 0;
+  if (IS_SPEC (operandType (left)) && IS_SPEC (operandType (right)))
+    {
+      letype = getSpec (operandType (left));
+      retype = getSpec (operandType (right));
+      sign = !(SPEC_USIGN (letype) | SPEC_USIGN (retype));
+    }
+
+  /* assign the amsops */
+  aopOp (left, ic, FALSE);
+  aopOp (right, ic, FALSE);
+  aopOp (result, ic, TRUE);
+
+  genCmp (right, left, result, ifx, sign);
+
+  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (result, NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genCmpLt - less than comparisons                                */
+/*-----------------------------------------------------------------*/
+static void
+genCmpLt (iCode * ic, iCode * ifx)
+{
+  operand *left, *right, *result;
+  sym_link *letype, *retype;
+  int sign;
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  left = IC_LEFT (ic);
+  right = IC_RIGHT (ic);
+  result = IC_RESULT (ic);
+
+  sign = 0;
+  if (IS_SPEC (operandType (left)) && IS_SPEC (operandType (right)))
+    {
+      letype = getSpec (operandType (left));
+      retype = getSpec (operandType (right));
+      sign = !(SPEC_USIGN (letype) | SPEC_USIGN (retype));
+    }
+
+  /* assign the amsops */
+  aopOp (left, ic, FALSE);
+  aopOp (right, ic, FALSE);
+  aopOp (result, ic, TRUE);
+
+  genCmp (left, right, result, ifx, sign);
+
+  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (result, NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genCmpEq - generates code for equal to                          */
+/*-----------------------------------------------------------------*/
+static void
+genCmpEq (iCode * ic, iCode * ifx)
+{
+  operand *left, *right, *result;
+  int size;
+  symbol *false_label;
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+  if (ifx)
+    DEBUGpic14_emitcode ("; ifx is non-null", "");
+  else
+    DEBUGpic14_emitcode ("; ifx is null", "");
+
+  aopOp ((left = IC_LEFT (ic)), ic, FALSE);
+  aopOp ((right = IC_RIGHT (ic)), ic, FALSE);
+  aopOp ((result = IC_RESULT (ic)), ic, TRUE);
+
+  DEBUGpic14_AopType (__LINE__, left, right, result);
+
+  /* if literal, move literal to right */
+  if (op_isLitLike (IC_LEFT (ic)))
+    {
+      operand *tmp = right;
+      right = left;
+      left = tmp;
+    }
+
+  false_label = NULL;
+  if (ifx && !IC_TRUE (ifx))
+    {
+      assert (IC_FALSE (ifx));
+      false_label = IC_FALSE (ifx);
+    }
+
+  size = min (AOP_SIZE (left), AOP_SIZE (right));
+  assert (!pic14_sameRegs (AOP (result), AOP (left)));
+  assert (!pic14_sameRegs (AOP (result), AOP (right)));
+
+  /* assume left != right */
+  {
+    int i;
+    for (i = 0; i < AOP_SIZE (result); i++)
+      {
+        emitpcode (POC_CLRF, popGet (AOP (result), i));
+      }
+  }
+
+  if (AOP_TYPE (right) == AOP_LIT)
+    {
+      unsigned long lit = ulFromVal (AOP (right)->aopu.aop_lit);
+      int i;
+      size = AOP_SIZE (left);
+      assert (!op_isLitLike (left));
+
+      switch (lit)
+        {
+        case 0:
+          mov2w (AOP (left), 0);
+          for (i = 1; i < size; i++)
+            emitpcode (POC_IORFW, popGet (AOP (left), i));
+          /* now Z is set iff `left == right' */
+          emitSKPZ;
+          if (!false_label)
+            false_label = newiTempLabel (NULL);
+          emitpcode (POC_GOTO, popGetLabel (false_label->key));
+          break;
+
+        default:
+          for (i = 0; i < size; i++)
+            {
+              mov2w (AOP (left), i);
+              emitpcode (POC_XORLW, popGetLit (lit >> (8 * i)));
+              /* now Z is cleared if `left != right' */
+              emitSKPZ;
+              if (!false_label)
+                false_label = newiTempLabel (NULL);
+              emitpcode (POC_GOTO, popGetLabel (false_label->key));
+            }                   // for i
+          break;
+        }                       // switch (lit)
+    }
+  else
+    {
+      /* right is no literal */
+      int i;
+
+      for (i = 0; i < size; i++)
+        {
+          mov2w (AOP (right), i);
+          emitpcode (POC_XORFW, popGet (AOP (left), i));
+          /* now Z is cleared if `left != right' */
+          emitSKPZ;
+          if (!false_label)
+            false_label = newiTempLabel (NULL);
+          emitpcode (POC_GOTO, popGetLabel (false_label->key));
+        }                       // for i
+    }
+
+  /* if we reach here, left == right */
+
+  if (AOP_SIZE (result) > 0)
+    {
+      emitpcode (POC_INCF, popGet (AOP (result), 0));
+    }
+
+  if (ifx && IC_TRUE (ifx))
+    {
+      emitpcode (POC_GOTO, popGetLabel (IC_TRUE (ifx)->key));
+    }
+
+  if (false_label && (!ifx || IC_TRUE (ifx)))
+    emitpLabel (false_label->key);
+
+  if (ifx)
+    ifx->generated = TRUE;
+
+  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (result, NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genAndOp - for && operation                                     */
+/*-----------------------------------------------------------------*/
+static void
+genAndOp (iCode * ic)
+{
+  operand *left, *right, *result;
+  /*     symbol *tlbl; */
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  /* note here that && operations that are in an
+     if statement are taken away by backPatchLabels
+     only those used in arthmetic operations remain */
+  aopOp ((left = IC_LEFT (ic)), ic, FALSE);
+  aopOp ((right = IC_RIGHT (ic)), ic, FALSE);
+  aopOp ((result = IC_RESULT (ic)), ic, FALSE);
+
+  DEBUGpic14_AopType (__LINE__, left, right, result);
+
+  emitpcode (POC_MOVFW, popGet (AOP (left), 0));
+  emitpcode (POC_ANDFW, popGet (AOP (right), 0));
+  emitpcode (POC_MOVWF, popGet (AOP (result), 0));
+
+  /* if both are bit variables */
+  /*     if (AOP_TYPE(left) == AOP_CRY && */
+  /*         AOP_TYPE(right) == AOP_CRY ) { */
+  /*         pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir); */
+  /*         pic14_emitcode("anl","c,%s",AOP(right)->aopu.aop_dir); */
+  /*         pic14_outBitC(result); */
+  /*     } else { */
+  /*         tlbl = newiTempLabel(NULL); */
+  /*         pic14_toBoolean(left);     */
+  /*         pic14_emitcode("jz","%05d_DS_",labelKey2num (tlbl->key)); */
+  /*         pic14_toBoolean(right); */
+  /*         pic14_emitcode("","%05d_DS_:",labelKey2num (tlbl->key)); */
+  /*         pic14_outBitAcc(result); */
+  /*     } */
+
+  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (result, NULL, ic, TRUE);
+}
+
+
+/*-----------------------------------------------------------------*/
+/* genOrOp - for || operation                                      */
+/*-----------------------------------------------------------------*/
+/*
+tsd pic port -
+modified this code, but it doesn't appear to ever get called
+*/
+
+static void
+genOrOp (iCode * ic)
+{
+  operand *left, *right, *result;
+  symbol *tlbl;
+  int i;
+
+  /* note here that || operations that are in an
+     if statement are taken away by backPatchLabels
+     only those used in arthmetic operations remain */
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  aopOp ((left = IC_LEFT (ic)), ic, FALSE);
+  aopOp ((right = IC_RIGHT (ic)), ic, FALSE);
+  aopOp ((result = IC_RESULT (ic)), ic, FALSE);
+
+  DEBUGpic14_AopType (__LINE__, left, right, result);
+
+  for (i = 0; i < AOP_SIZE (result); i++)
+    {
+      emitpcode (POC_CLRF, popGet (AOP (result), i));
+    }                           // for i
+
+  tlbl = newiTempLabel (NULL);
+  pic14_toBoolean (left);
+  emitSKPZ;
+  emitpcode (POC_GOTO, popGetLabel (tlbl->key));
+  pic14_toBoolean (right);
+  emitpLabel (tlbl->key);
+  /* here Z is clear IFF `left || right' */
+  emitSKPZ;
+  emitpcode (POC_INCF, popGet (AOP (result), 0));
+
+  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (result, NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* isLiteralBit - test if lit == 2^n                               */
+/*-----------------------------------------------------------------*/
+static int
+isLiteralBit (unsigned long lit)
+{
+  unsigned long pw[32] = { 1L, 2L, 4L, 8L, 16L, 32L, 64L, 128L,
+                           0x100L, 0x200L, 0x400L, 0x800L,
+                           0x1000L, 0x2000L, 0x4000L, 0x8000L,
+                           0x10000L, 0x20000L, 0x40000L, 0x80000L,
+                           0x100000L, 0x200000L, 0x400000L, 0x800000L,
+                           0x1000000L, 0x2000000L, 0x4000000L, 0x8000000L,
+                           0x10000000L, 0x20000000L, 0x40000000L, 0x80000000L
+                         };
+  int idx;
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  for (idx = 0; idx < 32; idx++)
+    if (lit == pw[idx])
+      return idx + 1;
+  return 0;
+}
+
+/*-----------------------------------------------------------------*/
+/* continueIfTrue -                                                */
+/*-----------------------------------------------------------------*/
+static void
+continueIfTrue (iCode * ic)
+{
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  if (IC_TRUE (ic))
+    {
+      emitpcode (POC_GOTO, popGetLabel (labelKey2num (IC_TRUE (ic)->key)));
+      pic14_emitcode ("ljmp", "%05d_DS_", labelKey2num (IC_FALSE (ic)->key));
+    }
+  ic->generated = TRUE;
+}
+
+/*-----------------------------------------------------------------*/
+/* jmpIfTrue -                                                     */
+/*-----------------------------------------------------------------*/
+static void
+jumpIfTrue (iCode * ic)
+{
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  if (!IC_TRUE (ic))
+    {
+      emitpcode (POC_GOTO, labelKey2num (popGetLabel (IC_TRUE (ic)->key)));
+      pic14_emitcode ("ljmp", "%05d_DS_", labelKey2num (IC_FALSE (ic)->key));
+    }
+  ic->generated = TRUE;
+}
+
+/*-----------------------------------------------------------------*/
+/* jmpTrueOrFalse -                                                */
+/*-----------------------------------------------------------------*/
+static void
+jmpTrueOrFalse (iCode * ic, symbol * tlbl)
+{
+  FENTRY;
+  // ugly but optimized by peephole
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  if (IC_TRUE (ic))
+    {
+      symbol *nlbl = newiTempLabel (NULL);
+      pic14_emitcode ("sjmp", "%05d_DS_", labelKey2num (nlbl->key));
+      pic14_emitcode ("", "%05d_DS_:", labelKey2num (tlbl->key));
+      pic14_emitcode ("ljmp", "%05d_DS_", labelKey2num (IC_TRUE (ic)->key));
+      pic14_emitcode ("", "%05d_DS_:", labelKey2num (nlbl->key));
+    }
+  else
+    {
+      pic14_emitcode ("ljmp", "%05d_DS_", labelKey2num (IC_FALSE (ic)->key));
+      pic14_emitcode ("", "%05d_DS_:", labelKey2num (tlbl->key));
+    }
+  ic->generated = TRUE;
+}
+
+/*-----------------------------------------------------------------*/
+/* genAnd  - code for and                                          */
+/*-----------------------------------------------------------------*/
+static void
+genAnd (iCode * ic, iCode * ifx)
+{
+  operand *left, *right, *result;
+  int size, offset = 0;
+  unsigned long lit = 0L;
+  int bytelit = 0;
+  resolvedIfx rIfx;
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  aopOp ((left = IC_LEFT (ic)), ic, FALSE);
+  aopOp ((right = IC_RIGHT (ic)), ic, FALSE);
+  aopOp ((result = IC_RESULT (ic)), ic, TRUE);
+
+  resolveIfx (&rIfx, ifx);
+
+  /* if left is a literal & right is not then exchange them */
+  if ((AOP_TYPE (left) == AOP_LIT && AOP_TYPE (right) != AOP_LIT) || AOP_NEEDSACC (left))
+    {
+      operand *tmp = right;
+      right = left;
+      left = tmp;
+    }
+
+  /* if result = right then exchange them */
+  if (pic14_sameRegs (AOP (result), AOP (right)))
+    {
+      operand *tmp = right;
+      right = left;
+      left = tmp;
+    }
+
+  /* if right is bit then exchange them */
+  if (AOP_TYPE (right) == AOP_CRY && AOP_TYPE (left) != AOP_CRY)
+    {
+      operand *tmp = right;
+      right = left;
+      left = tmp;
+    }
+  if (AOP_TYPE (right) == AOP_LIT)
+    lit = ulFromVal (AOP (right)->aopu.aop_lit);
+
+  size = AOP_SIZE (result);
+
+  DEBUGpic14_AopType (__LINE__, left, right, result);
+
+  // if(bit & yy)
+  // result = bit & yy;
+  if (AOP_TYPE (left) == AOP_CRY)
+    {
+      // c = bit & literal;
+      if (AOP_TYPE (right) == AOP_LIT)
+        {
+          if (lit & 1)
+            {
+              if (size && pic14_sameRegs (AOP (result), AOP (left)))
+                // no change
+                goto release;
+              pic14_emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
+            }
+          else
+            {
+              // bit(result) = 0;
+              if (size && (AOP_TYPE (result) == AOP_CRY))
+                {
+                  pic14_emitcode ("clr", "%s", AOP (result)->aopu.aop_dir);
+                  goto release;
+                }
+              if ((AOP_TYPE (result) == AOP_CRY) && ifx)
+                {
+                  jumpIfTrue (ifx);
+                  goto release;
+                }
+              pic14_emitcode ("clr", "c");
+            }
+        }
+      else
+        {
+          if (AOP_TYPE (right) == AOP_CRY)
+            {
+              // c = bit & bit;
+              pic14_emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
+              pic14_emitcode ("anl", "c,%s", AOP (left)->aopu.aop_dir);
+            }
+          else
+            {
+              // c = bit & val;
+              MOVA (aopGet (AOP (right), 0, FALSE, FALSE));
+              // c = lsb
+              pic14_emitcode ("rrc", "a");
+              pic14_emitcode ("anl", "c,%s", AOP (left)->aopu.aop_dir);
+            }
+        }
+      // bit = c
+      // val = c
+      if (size)
+        pic14_outBitC (result);
+      // if(bit & ...)
+      else if ((AOP_TYPE (result) == AOP_CRY) && ifx)
+        genIfxJump (ifx, "c");
+      goto release;
+    }
+
+  // if(val & 0xZZ)       - size = 0, ifx != FALSE  -
+  // bit = val & 0xZZ     - size = 1, ifx = FALSE -
+  if ((AOP_TYPE (right) == AOP_LIT) && (AOP_TYPE (result) == AOP_CRY) && (AOP_TYPE (left) != AOP_CRY))
+    {
+      int posbit = isLiteralBit (lit);
+      /* left &  2^n */
+      if (posbit)
+        {
+          posbit--;
+          //MOVA(aopGet(AOP(left),posbit>>3,FALSE,FALSE));
+          // bit = left & 2^n
+          if (size)
+            pic14_emitcode ("mov", "c,acc.%d", posbit & 0x07);
+          // if(left &  2^n)
+          else
+            {
+              if (ifx)
+                {
+                  int offset = 0;
+                  while (posbit > 7)
+                    {
+                      posbit -= 8;
+                      offset++;
+                    }
+                  emitpcode (((rIfx.condition) ? POC_BTFSC : POC_BTFSS),
+                             newpCodeOpBit (aopGet (AOP (left), offset, FALSE, FALSE), posbit, 0));
+                  emitpcode (POC_GOTO, popGetLabel (rIfx.lbl->key));
+
+                  ifx->generated = TRUE;
+                }
+              goto release;
+            }
+        }
+      else
+        {
+          symbol *tlbl = newiTempLabel (NULL);
+          int sizel = AOP_SIZE (left);
+          if (size)
+            pic14_emitcode ("setb", "c");
+          while (sizel--)
+            {
+              if ((bytelit = ((lit >> (offset * 8)) & 0x0FFL)) != 0x0L)
+                {
+                  // byte ==  2^n ?
+                  if ((posbit = isLiteralBit (bytelit)) != 0)
+                    {
+                      emitpcode (POC_BTFSC,
+                                 newpCodeOpBit (aopGet (AOP (left), offset, FALSE, FALSE), posbit - 1, 0));
+                    }
+                  else
+                    {
+                      mov2w (AOP (left), offset);
+                      emitpcode (POC_ANDLW, newpCodeOpLit (bytelit & 0x0ff));
+                      emitSKPZ;
+                    }
+                  emitpcode (POC_GOTO, popGetLabel (rIfx.condition ?
+                                                    rIfx.lbl->key : tlbl->key));
+                }
+                offset++;
+            }
+          if (!rIfx.condition)
+            {
+              emitpcode (POC_GOTO, popGetLabel (rIfx.lbl->key));
+            }
+          emitpLabel(tlbl->key);
+          ifx->generated = TRUE;
+          // bit = left & literal
+          if (size)
+            {
+              pic14_emitcode ("clr", "c");
+              pic14_emitcode ("", "%05d_DS_:", labelKey2num (tlbl->key));
+            }
+          // if(left & literal)
+          else
+            {
+              if (ifx)
+                jmpTrueOrFalse (ifx, tlbl);
+              goto release;
+            }
+        }
+      pic14_outBitC (result);
+      goto release;
+    }
+
+  /* if left is same as result */
+  if (pic14_sameRegs (AOP (result), AOP (left)))
+    {
+      int know_W = -1;
+      for (; size--; offset++, lit >>= 8)
+        {
+          if (AOP_TYPE (right) == AOP_LIT)
+            {
+              switch (lit & 0xff)
+                {
+                case 0x00:
+                  /*  and'ing with 0 has clears the result */
+                  emitpcode (POC_CLRF, popGet (AOP (result), offset));
+                  break;
+                case 0xff:
+                  /* and'ing with 0xff is a nop when the result and left are the same */
+                  break;
+
+                default:
+                {
+                  int p = my_powof2 ((~lit) & 0xff);
+                  if (p >= 0)
+                    {
+                      /* only one bit is set in the literal, so use a bcf instruction */
+                      emitpcode (POC_BCF, newpCodeOpBit (aopGet (AOP (left), offset, FALSE, FALSE), p, 0));
+
+                    }
+                  else
+                    {
+                      if (know_W != (int) (lit & 0xff))
+                        emitpcode (POC_MOVLW, popGetLit (lit & 0xff));
+                      know_W = lit & 0xff;
+                      emitpcode (POC_ANDWF, popGet (AOP (left), offset));
+                    }
+                }
+                }
+            }
+          else
+            {
+              emitpcode (POC_MOVFW, popGet (AOP (right), offset));
+              emitpcode (POC_ANDWF, popGet (AOP (left), offset));
+            }
+        }
+
+    }
+  else
+    {
+      // left & result in different registers
+      if (AOP_TYPE (result) == AOP_CRY)
+        {
+          // result = bit
+          // if(size), result in bit
+          // if(!size && ifx), conditional oper: if(left & right)
+          symbol *tlbl = newiTempLabel (NULL);
+          int sizer = min (AOP_SIZE (left), AOP_SIZE (right));
+          if (size)
+            pic14_emitcode ("setb", "c");
+          while (sizer--)
+            {
+              MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
+              pic14_emitcode ("anl", "a,%s", aopGet (AOP (left), offset, FALSE, FALSE));
+              pic14_emitcode ("jnz", "%05d_DS_", labelKey2num (tlbl->key));
+              offset++;
+            }
+          if (size)
+            {
+              CLRC;
+              pic14_emitcode ("", "%05d_DS_:", labelKey2num (tlbl->key));
+              pic14_outBitC (result);
+            }
+          else if (ifx)
+            jmpTrueOrFalse (ifx, tlbl);
+        }
+      else
+        {
+          for (; (size--); offset++)
+            {
+              // normal case
+              // result = left & right
+              if (AOP_TYPE (right) == AOP_LIT)
+                {
+                  int t = (lit >> (offset * 8)) & 0x0FFL;
+                  switch (t)
+                    {
+                    case 0x00:
+                      emitpcode (POC_CLRF, popGet (AOP (result), offset));
+                      break;
+                    case 0xff:
+                      emitpcode (POC_MOVFW, popGet (AOP (left), offset));
+                      emitpcode (POC_MOVWF, popGet (AOP (result), offset));
+                      break;
+                    default:
+                      emitpcode (POC_MOVLW, popGetLit (t));
+                      emitpcode (POC_ANDFW, popGet (AOP (left), offset));
+                      emitpcode (POC_MOVWF, popGet (AOP (result), offset));
+                    }
+                  continue;
+                }
+
+              emitpcode (POC_MOVFW, popGet (AOP (right), offset));
+              emitpcode (POC_ANDFW, popGet (AOP (left), offset));
+              emitpcode (POC_MOVWF, popGet (AOP (result), offset));
+            }
+        }
+    }
+
+release:
+  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (result, NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genOr  - code for or                                            */
+/*-----------------------------------------------------------------*/
+static void
+genOr (iCode * ic, iCode * ifx)
+{
+  operand *left, *right, *result;
+  int size, offset = 0;
+  unsigned long lit = 0L;
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+  aopOp ((left = IC_LEFT (ic)), ic, FALSE);
+  aopOp ((right = IC_RIGHT (ic)), ic, FALSE);
+  aopOp ((result = IC_RESULT (ic)), ic, TRUE);
+
+  DEBUGpic14_AopType (__LINE__, left, right, result);
+
+  /* if left is a literal & right is not then exchange them */
+  if ((AOP_TYPE (left) == AOP_LIT && AOP_TYPE (right) != AOP_LIT) || AOP_NEEDSACC (left))
+    {
+      operand *tmp = right;
+      right = left;
+      left = tmp;
+    }
+
+  /* if result = right then exchange them */
+  if (pic14_sameRegs (AOP (result), AOP (right)))
+    {
+      operand *tmp = right;
+      right = left;
+      left = tmp;
+    }
+
+  /* if right is bit then exchange them */
+  if (AOP_TYPE (right) == AOP_CRY && AOP_TYPE (left) != AOP_CRY)
+    {
+      operand *tmp = right;
+      right = left;
+      left = tmp;
+    }
+
+  DEBUGpic14_AopType (__LINE__, left, right, result);
+
+  if (AOP_TYPE (right) == AOP_LIT)
+    lit = ulFromVal (AOP (right)->aopu.aop_lit);
+
+  size = AOP_SIZE (result);
+
+  // if(bit | yy)
+  // xx = bit | yy;
+  if (AOP_TYPE (left) == AOP_CRY)
+    {
+      if (AOP_TYPE (right) == AOP_LIT)
+        {
+          // c = bit & literal;
+          if (lit)
+            {
+              // lit != 0 => result = 1
+              if (AOP_TYPE (result) == AOP_CRY)
+                {
+                  if (size)
+                    emitpcode (POC_BSF, popGet (AOP (result), 0));
+                  //pic14_emitcode("bsf","(%s >> 3), (%s & 7)",
+                  //   AOP(result)->aopu.aop_dir,
+                  //   AOP(result)->aopu.aop_dir);
+                  else if (ifx)
+                    continueIfTrue (ifx);
+                  goto release;
+                }
+            }
+          else
+            {
+              // lit == 0 => result = left
+              if (size && pic14_sameRegs (AOP (result), AOP (left)))
+                goto release;
+              pic14_emitcode (";XXX mov", "c,%s  %s,%d", AOP (left)->aopu.aop_dir, __FILE__, __LINE__);
+            }
+        }
+      else
+        {
+          if (AOP_TYPE (right) == AOP_CRY)
+            {
+              if (pic14_sameRegs (AOP (result), AOP (left)))
+                {
+                  // c = bit | bit;
+                  emitpcode (POC_BCF, popGet (AOP (result), 0));
+                  emitpcode (POC_BTFSC, popGet (AOP (right), 0));
+                  emitpcode (POC_BSF, popGet (AOP (result), 0));
+
+                  pic14_emitcode ("bcf", "(%s >> 3), (%s & 7)", AOP (result)->aopu.aop_dir, AOP (result)->aopu.aop_dir);
+                  pic14_emitcode ("btfsc", "(%s >> 3), (%s & 7)", AOP (right)->aopu.aop_dir, AOP (right)->aopu.aop_dir);
+                  pic14_emitcode ("bsf", "(%s >> 3), (%s & 7)", AOP (result)->aopu.aop_dir, AOP (result)->aopu.aop_dir);
+                }
+              else
+                {
+                  emitpcode (POC_BCF, popGet (AOP (result), 0));
+                  emitpcode (POC_BTFSS, popGet (AOP (right), 0));
+                  emitpcode (POC_BTFSC, popGet (AOP (left), 0));
+                  emitpcode (POC_BSF, popGet (AOP (result), 0));
+                }
+            }
+          else
+            {
+              // c = bit | val;
+              symbol *tlbl = newiTempLabel (NULL);
+              pic14_emitcode (";XXX ", " %s,%d", __FILE__, __LINE__);
+
+
+              emitpcode (POC_BCF, popGet (AOP (result), 0));
+
+              if (!((AOP_TYPE (result) == AOP_CRY) && ifx))
+                pic14_emitcode (";XXX setb", "c");
+              pic14_emitcode (";XXX jb", "%s,%05d_DS_", AOP (left)->aopu.aop_dir, labelKey2num (tlbl->key));
+              pic14_toBoolean (right);
+              pic14_emitcode (";XXX jnz", "%05d_DS_", labelKey2num (tlbl->key));
+              if ((AOP_TYPE (result) == AOP_CRY) && ifx)
+                {
+                  jmpTrueOrFalse (ifx, tlbl);
+                  goto release;
+                }
+              else
+                {
+                  CLRC;
+                  pic14_emitcode ("", "%05d_DS_:", labelKey2num (tlbl->key));
+                }
+            }
+        }
+      // bit = c
+      // val = c
+      if (size)
+        pic14_outBitC (result);
+      // if(bit | ...)
+      else if ((AOP_TYPE (result) == AOP_CRY) && ifx)
+        genIfxJump (ifx, "c");
+      goto release;
+    }
+
+  // if(val | 0xZZ)       - size = 0, ifx != FALSE  -
+  // bit = val | 0xZZ     - size = 1, ifx = FALSE -
+  if ((AOP_TYPE (right) == AOP_LIT) && (AOP_TYPE (result) == AOP_CRY) && (AOP_TYPE (left) != AOP_CRY))
+    {
+      if (lit)
+        {
+          pic14_emitcode (";XXX ", " %s,%d", __FILE__, __LINE__);
+          // result = 1
+          if (size)
+            pic14_emitcode (";XXX setb", "%s", AOP (result)->aopu.aop_dir);
+          else
+            continueIfTrue (ifx);
+          goto release;
+        }
+      else
+        {
+          pic14_emitcode (";XXX ", " %s,%d", __FILE__, __LINE__);
+          // lit = 0, result = boolean(left)
+          if (size)
+            pic14_emitcode (";XXX setb", "c");
+          pic14_toBoolean (right);
+          if (size)
+            {
+              symbol *tlbl = newiTempLabel (NULL);
+              pic14_emitcode (";XXX jnz", "%05d_DS_", labelKey2num (tlbl->key));
+              CLRC;
+              pic14_emitcode ("", "%05d_DS_:", labelKey2num (tlbl->key));
+            }
+          else
+            {
+              genIfxJump (ifx, "a");
+              goto release;
+            }
+        }
+      pic14_outBitC (result);
+      goto release;
+    }
+
+  /* if left is same as result */
+  if (pic14_sameRegs (AOP (result), AOP (left)))
+    {
+      int know_W = -1;
+      for (; size--; offset++, lit >>= 8)
+        {
+          if (AOP_TYPE (right) == AOP_LIT)
+            {
+              if ((lit & 0xff) == 0)
+                /*  or'ing with 0 has no effect */
+                continue;
+              else
+                {
+                  int p = my_powof2 (lit & 0xff);
+                  if (p >= 0)
+                    {
+                      /* only one bit is set in the literal, so use a bsf instruction */
+                      emitpcode (POC_BSF, newpCodeOpBit (aopGet (AOP (left), offset, FALSE, FALSE), p, 0));
+                    }
+                  else
+                    {
+                      if (know_W != (int) (lit & 0xff))
+                        emitpcode (POC_MOVLW, popGetLit (lit & 0xff));
+                      know_W = lit & 0xff;
+                      emitpcode (POC_IORWF, popGet (AOP (left), offset));
+                    }
+
+                }
+            }
+          else
+            {
+              emitpcode (POC_MOVFW, popGet (AOP (right), offset));
+              emitpcode (POC_IORWF, popGet (AOP (left), offset));
+            }
+        }
+    }
+  else
+    {
+      // left & result in different registers
+      if (AOP_TYPE (result) == AOP_CRY)
+        {
+          // result = bit
+          // if(size), result in bit
+          // if(!size && ifx), conditional oper: if(left | right)
+          symbol *tlbl = newiTempLabel (NULL);
+          int sizer = max (AOP_SIZE (left), AOP_SIZE (right));
+          pic14_emitcode (";XXX ", " %s,%d", __FILE__, __LINE__);
+
+
+          if (size)
+            pic14_emitcode (";XXX setb", "c");
+          while (sizer--)
+            {
+              MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
+              pic14_emitcode (";XXX orl", "a,%s", aopGet (AOP (left), offset, FALSE, FALSE));
+              pic14_emitcode (";XXX jnz", "%05d_DS_", labelKey2num (tlbl->key));
+              offset++;
+            }
+          if (size)
+            {
+              CLRC;
+              pic14_emitcode ("", "%05d_DS_:", labelKey2num (tlbl->key));
+              pic14_outBitC (result);
+            }
+          else if (ifx)
+            jmpTrueOrFalse (ifx, tlbl);
+        }
+      else
+        for (; (size--); offset++)
+          {
+            // normal case
+            // result = left | right
+            if (AOP_TYPE (right) == AOP_LIT)
+              {
+                int t = (lit >> (offset * 8)) & 0x0FFL;
+                switch (t)
+                  {
+                  case 0x00:
+                    emitpcode (POC_MOVFW, popGet (AOP (left), offset));
+                    emitpcode (POC_MOVWF, popGet (AOP (result), offset));
+
+                    break;
+                  default:
+                    emitpcode (POC_MOVLW, popGetLit (t));
+                    emitpcode (POC_IORFW, popGet (AOP (left), offset));
+                    emitpcode (POC_MOVWF, popGet (AOP (result), offset));
+                  }
+                continue;
+              }
+
+            // faster than result <- left, anl result,right
+            // and better if result is SFR
+            emitpcode (POC_MOVFW, popGet (AOP (right), offset));
+            emitpcode (POC_IORFW, popGet (AOP (left), offset));
+            emitpcode (POC_MOVWF, popGet (AOP (result), offset));
+          }
+    }
+
+release:
+  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (result, NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genXor - code for xclusive or                                   */
+/*-----------------------------------------------------------------*/
+static void
+genXor (iCode * ic, iCode * ifx)
+{
+  operand *left, *right, *result;
+  int size, offset = 0;
+  unsigned long lit = 0L;
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+  aopOp ((left = IC_LEFT (ic)), ic, FALSE);
+  aopOp ((right = IC_RIGHT (ic)), ic, FALSE);
+  aopOp ((result = IC_RESULT (ic)), ic, TRUE);
+
+  /* if left is a literal & right is not ||
+     if left needs acc & right does not */
+  if ((AOP_TYPE (left) == AOP_LIT && AOP_TYPE (right) != AOP_LIT) || (AOP_NEEDSACC (left) && !AOP_NEEDSACC (right)))
+    {
+      operand *tmp = right;
+      right = left;
+      left = tmp;
+    }
+
+  /* if result = right then exchange them */
+  if (pic14_sameRegs (AOP (result), AOP (right)))
+    {
+      operand *tmp = right;
+      right = left;
+      left = tmp;
+    }
+
+  /* if right is bit then exchange them */
+  if (AOP_TYPE (right) == AOP_CRY && AOP_TYPE (left) != AOP_CRY)
+    {
+      operand *tmp = right;
+      right = left;
+      left = tmp;
+    }
+  if (AOP_TYPE (right) == AOP_LIT)
+    lit = ulFromVal (AOP (right)->aopu.aop_lit);
+
+  size = AOP_SIZE (result);
+
+  // if(bit ^ yy)
+  // xx = bit ^ yy;
+  if (AOP_TYPE (left) == AOP_CRY)
+    {
+      if (AOP_TYPE (right) == AOP_LIT)
+        {
+          // c = bit & literal;
+          if (lit >> 1)
+            {
+              // lit>>1  != 0 => result = 1
+              if (AOP_TYPE (result) == AOP_CRY)
+                {
+                  if (size)
+                    {
+                      emitpcode (POC_BSF, popGet (AOP (result), offset));
+                      pic14_emitcode ("setb", "%s", AOP (result)->aopu.aop_dir);
+                    }
+                  else if (ifx)
+                    continueIfTrue (ifx);
+                  goto release;
+                }
+              pic14_emitcode ("setb", "c");
+            }
+          else
+            {
+              // lit == (0 or 1)
+              if (lit == 0)
+                {
+                  // lit == 0, result = left
+                  if (size && pic14_sameRegs (AOP (result), AOP (left)))
+                    goto release;
+                  pic14_emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
+                }
+              else
+                {
+                  // lit == 1, result = not(left)
+                  if (size && pic14_sameRegs (AOP (result), AOP (left)))
+                    {
+                      emitpcode (POC_MOVLW, popGet (AOP (result), offset));
+                      emitpcode (POC_XORWF, popGet (AOP (result), offset));
+                      pic14_emitcode ("cpl", "%s", AOP (result)->aopu.aop_dir);
+                      goto release;
+                    }
+                  else
+                    {
+                      assert (!"incomplete genXor");
+                      pic14_emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
+                      pic14_emitcode ("cpl", "c");
+                    }
+                }
+            }
+
+        }
+      else
+        {
+          // right != literal
+          symbol *tlbl = newiTempLabel (NULL);
+          if (AOP_TYPE (right) == AOP_CRY)
+            {
+              // c = bit ^ bit;
+              pic14_emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
+            }
+          else
+            {
+              int sizer = AOP_SIZE (right);
+              // c = bit ^ val
+              // if val>>1 != 0, result = 1
+              pic14_emitcode ("setb", "c");
+              while (sizer)
+                {
+                  MOVA (aopGet (AOP (right), sizer - 1, FALSE, FALSE));
+                  if (sizer == 1)
+                    // test the msb of the lsb
+                    pic14_emitcode ("anl", "a,#0xfe");
+                  pic14_emitcode ("jnz", "%05d_DS_", labelKey2num (tlbl->key));
+                  sizer--;
+                }
+              // val = (0,1)
+              pic14_emitcode ("rrc", "a");
+            }
+          pic14_emitcode ("jnb", "%s,%05d_DS_", AOP (left)->aopu.aop_dir, (labelKey2num (tlbl->key)));
+          pic14_emitcode ("cpl", "c");
+          pic14_emitcode ("", "%05d_DS_:", (labelKey2num (tlbl->key)));
+        }
+      // bit = c
+      // val = c
+      if (size)
+        pic14_outBitC (result);
+      // if(bit | ...)
+      else if ((AOP_TYPE (result) == AOP_CRY) && ifx)
+        genIfxJump (ifx, "c");
+      goto release;
+    }
+
+  if (pic14_sameRegs (AOP (result), AOP (left)))
+    {
+      /* if left is same as result */
+      for (; size--; offset++)
+        {
+          if (AOP_TYPE (right) == AOP_LIT)
+            {
+              int t = (lit >> (offset * 8)) & 0x0FFL;
+              if (t == 0x00L)
+                continue;
+              else
+                {
+                  emitpcode (POC_MOVLW, popGetLit (t));
+                  emitpcode (POC_XORWF, popGet (AOP (left), offset));
+                }
+            }
+          else
+            {
+              emitpcode (POC_MOVFW, popGet (AOP (right), offset));
+              emitpcode (POC_XORWF, popGet (AOP (left), offset));
+            }
+        }
+    }
+  else
+    {
+      // left & result in different registers
+      if (AOP_TYPE (result) == AOP_CRY)
+        {
+          // result = bit
+          // if(size), result in bit
+          // if(!size && ifx), conditional oper: if(left ^ right)
+          symbol *tlbl = newiTempLabel (NULL);
+          int sizer = max (AOP_SIZE (left), AOP_SIZE (right));
+          if (size)
+            pic14_emitcode ("setb", "c");
+          while (sizer--)
+            {
+              if ((AOP_TYPE (right) == AOP_LIT) && (((lit >> (offset * 8)) & 0x0FFL) == 0x00L))
+                {
+                  MOVA (aopGet (AOP (left), offset, FALSE, FALSE));
+                }
+              else
+                {
+                  MOVA (aopGet (AOP (right), offset, FALSE, FALSE));
+                  pic14_emitcode ("xrl", "a,%s", aopGet (AOP (left), offset, FALSE, FALSE));
+                }
+              pic14_emitcode ("jnz", "%05d_DS_", labelKey2num (tlbl->key));
+              offset++;
+            }
+          if (size)
+            {
+              CLRC;
+              pic14_emitcode ("", "%05d_DS_:", labelKey2num (tlbl->key));
+              pic14_outBitC (result);
+            }
+          else if (ifx)
+            jmpTrueOrFalse (ifx, tlbl);
+        }
+      else
+        for (; (size--); offset++)
+          {
+            // normal case
+            // result = left & right
+            if (AOP_TYPE (right) == AOP_LIT)
+              {
+                int t = (lit >> (offset * 8)) & 0x0FFL;
+                switch (t)
+                  {
+                  case 0x00:
+                    emitpcode (POC_MOVFW, popGet (AOP (left), offset));
+                    emitpcode (POC_MOVWF, popGet (AOP (result), offset));
+                    break;
+                  case 0xff:
+                    emitpcode (POC_COMFW, popGet (AOP (left), offset));
+                    emitpcode (POC_MOVWF, popGet (AOP (result), offset));
+                    break;
+                  default:
+                    emitpcode (POC_MOVLW, popGetLit (t));
+                    emitpcode (POC_XORFW, popGet (AOP (left), offset));
+                    emitpcode (POC_MOVWF, popGet (AOP (result), offset));
+                  }
+                continue;
+              }
+
+            // faster than result <- left, anl result,right
+            // and better if result is SFR
+            emitpcode (POC_MOVFW, popGet (AOP (right), offset));
+            emitpcode (POC_XORFW, popGet (AOP (left), offset));
+            emitpcode (POC_MOVWF, popGet (AOP (result), offset));
+          }
+    }
+
+release:
+  freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
+  freeAsmop (result, NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genInline - write the inline code out                           */
+/*-----------------------------------------------------------------*/
+static void
+pic14_genInline (iCode * ic)
+{
+  char *buffer, *bp, *bp1;
+  bool inComment = FALSE;
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+  genLine.lineElement.isInline += (!options.asmpeep);
+
+  buffer = bp = bp1 = Safe_strdup (IC_INLINE (ic));
+
+  while (*bp)
+    {
+      switch (*bp)
+        {
+        case ';':
+          inComment = TRUE;
+          ++bp;
+          break;
+
+        case '\x87':
+        case '\n':
+          inComment = FALSE;
+          *bp++ = '\0';
+          if (*bp1)
+            addpCode2pBlock (pb, newpCodeAsmDir (bp1, NULL));   // inline directly, no process
+          bp1 = bp;
+          break;
+
+        default:
+          /* Add \n for labels, not dirs such as c:\mydir */
+          if (!inComment && (*bp == ':') && (isspace ((unsigned char) bp[1])))
+            {
+              ++bp;
+              *bp = '\0';
+              ++bp;
+              /* print label, use this special format with NULL directive
+               * to denote that the argument should not be indented with tab */
+              addpCode2pBlock (pb, newpCodeAsmDir (NULL, bp1)); // inline directly, no process
+              bp1 = bp;
+            }
+          else
+            ++bp;
+          break;
+        }
+    }
+  if ((bp1 != bp) && *bp1)
+    addpCode2pBlock (pb, newpCodeAsmDir (bp1, NULL));   // inline directly, no process
+
+  Safe_free (buffer);
+
+  /* consumed; we can free it here */
+  dbuf_free (IC_INLINE (ic));
+
+  genLine.lineElement.isInline -= (!options.asmpeep);
+}
+
+/*-----------------------------------------------------------------*/
+/* genRRC - rotate right with carry                                */
+/*-----------------------------------------------------------------*/
+static void
+genRRC (iCode * ic)
+{
+  operand *left, *result;
+  int size, offset = 0, same;
+
+  FENTRY;
+  /* rotate right with carry */
+  left = IC_LEFT (ic);
+  result = IC_RESULT (ic);
+  aopOp (left, ic, FALSE);
+  aopOp (result, ic, FALSE);
+
+  DEBUGpic14_AopType (__LINE__, left, NULL, result);
+
+  same = pic14_sameRegs (AOP (result), AOP (left));
+
+  size = AOP_SIZE (result);
+
+  /* get the lsb and put it into the carry */
+  emitpcode (POC_RRFW, popGet (AOP (left), size - 1));
+
+  offset = 0;
+
+  while (size--)
+    {
+      if (same)
+        {
+          emitpcode (POC_RRF, popGet (AOP (left), offset));
+        }
+      else
+        {
+          emitpcode (POC_RRFW, popGet (AOP (left), offset));
+          emitpcode (POC_MOVWF, popGet (AOP (result), offset));
+        }
+
+      offset++;
+    }
+
+  freeAsmop (left, NULL, ic, TRUE);
+  freeAsmop (result, NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genRLC - generate code for rotate left with carry               */
+/*-----------------------------------------------------------------*/
+static void
+genRLC (iCode * ic)
+{
+  operand *left, *result;
+  int size, offset = 0;
+  int same;
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  /* rotate right with carry */
+  left = IC_LEFT (ic);
+  result = IC_RESULT (ic);
+  aopOp (left, ic, FALSE);
+  aopOp (result, ic, FALSE);
+
+  DEBUGpic14_AopType (__LINE__, left, NULL, result);
+
+  same = pic14_sameRegs (AOP (result), AOP (left));
+
+  /* move it to the result */
+  size = AOP_SIZE (result);
+
+  /* get the msb and put it into the carry */
+  emitpcode (POC_RLFW, popGet (AOP (left), size - 1));
+
+  offset = 0;
+
+  while (size--)
+    {
+      if (same)
+        {
+          emitpcode (POC_RLF, popGet (AOP (left), offset));
+        }
+      else
+        {
+          emitpcode (POC_RLFW, popGet (AOP (left), offset));
+          emitpcode (POC_MOVWF, popGet (AOP (result), offset));
+        }
+
+      offset++;
+    }
+
+
+  freeAsmop (left, NULL, ic, TRUE);
+  freeAsmop (result, NULL, ic, TRUE);
+}
+
+static void
+genGetABit (iCode * ic)
+{
+  operand *left, *right, *result;
+  int shCount;
+  int offset;
+  int i;
+
+  left = IC_LEFT (ic);
+  right = IC_RIGHT (ic);
+  result = IC_RESULT (ic);
+
+  aopOp (left, ic, FALSE);
+  aopOp (right, ic, FALSE);
+  aopOp (result, ic, TRUE);
+
+  shCount = (int) ulFromVal (AOP (right)->aopu.aop_lit);
+  offset = shCount / 8;
+  shCount %= 8;
+
+  /* load and mask the source byte */
+  mov2w (AOP (left), offset);
+  emitpcode (POC_ANDLW, popGetLit (1 << shCount));
+
+  /* move selected bit to bit 0 */
+  switch (shCount)
+    {
+    case 0:
+      /* nothing more to do */
+      break;
+    default:
+      /* keep W==0, force W=0x01 otherwise */
+      emitSKPZ;
+      emitpcode (POC_MOVLW, popGetLit (1));
+      break;
+    }                           // switch
+
+  /* write result */
+  emitpcode (POC_MOVWF, popGet (AOP (result), 0));
+
+  for (i = 1; i < AOP_SIZE (result); ++i)
+    {
+      emitpcode (POC_CLRF, popGet (AOP (result), i));
+    }                           // for
+
+  freeAsmop (left, NULL, ic, TRUE);
+  freeAsmop (right, NULL, ic, TRUE);
+  freeAsmop (result, NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genGetHbit - generates code get highest order bit               */
+/*-----------------------------------------------------------------*/
+static void
+genGetHbit (iCode * ic)
+{
+  operand *left, *result;
+  left = IC_LEFT (ic);
+  result = IC_RESULT (ic);
+  aopOp (left, ic, FALSE);
+  aopOp (result, ic, FALSE);
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  /* get the highest order byte into a */
+  MOVA (aopGet (AOP (left), AOP_SIZE (left) - 1, FALSE, FALSE));
+  if (AOP_TYPE (result) == AOP_CRY)
+    {
+      pic14_emitcode ("rlc", "a");
+      pic14_outBitC (result);
+    }
+  else
+    {
+      pic14_emitcode ("rl", "a");
+      pic14_emitcode ("anl", "a,#0x01");
+      pic14_outAcc (result);
+    }
+
+
+  freeAsmop (left, NULL, ic, TRUE);
+  freeAsmop (result, NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* AccLsh - shift left accumulator by known count                  */
+/* MARK: pic14 always rotates through CARRY!                       */
+/*-----------------------------------------------------------------*/
+static void
+AccLsh (pCodeOp * pcop, int shCount)
+{
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  shCount &= 0x0007;            // shCount : 0..7
+  switch (shCount)
+    {
+    case 0:
+      return;
+      break;
+    case 1:
+      emitCLRC;
+      emitpcode (POC_RLF, pcop);
+      return;
+      break;
+    case 2:
+      emitpcode (POC_RLF, pcop);
+      emitpcode (POC_RLF, pcop);
+      break;
+    case 3:
+      emitpcode (POC_RLF, pcop);
+      emitpcode (POC_RLF, pcop);
+      emitpcode (POC_RLF, pcop);
+      break;
+    case 4:
+      emitpcode (POC_SWAPF, pcop);
+      break;
+    case 5:
+      emitpcode (POC_SWAPF, pcop);
+      emitpcode (POC_RLF, pcop);
+      break;
+    case 6:
+      emitpcode (POC_SWAPF, pcop);
+      emitpcode (POC_RLF, pcop);
+      emitpcode (POC_RLF, pcop);
+      break;
+    case 7:
+      emitpcode (POC_RRFW, pcop);
+      emitpcode (POC_RRF, pcop);
+      break;
+    }
+  /* clear invalid bits */
+  emitpcode (POC_MOVLW, popGetLit ((unsigned char) (~((1UL << shCount) - 1))));
+  emitpcode (POC_ANDWF, pcop);
+}
+
+/*-----------------------------------------------------------------*/
+/* AccRsh - shift right accumulator by known count                 */
+/* MARK: pic14 always rotates through CARRY!                       */
+/* maskmode - 0: leave invalid bits undefined (caller should mask) */
+/*            1: mask out invalid bits (zero-extend)               */
+/*            2: sign-extend result (pretty slow)                  */
+/*-----------------------------------------------------------------*/
+static void
+AccRsh (pCodeOp * pcop, int shCount, int mask_mode)
+{
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  shCount &= 0x0007;            // shCount : 0..7
+  switch (shCount)
+    {
+    case 0:
+      return;
+      break;
+    case 1:
+      /* load sign if needed */
+      if (mask_mode == 2)
+        emitpcode (POC_RLFW, pcop);
+      else if (mask_mode == 1)
+        emitCLRC;
+      emitpcode (POC_RRF, pcop);
+      return;
+      break;
+    case 2:
+      /* load sign if needed */
+      if (mask_mode == 2)
+        emitpcode (POC_RLFW, pcop);
+      emitpcode (POC_RRF, pcop);
+      /* load sign if needed */
+      if (mask_mode == 2)
+        emitpcode (POC_RLFW, pcop);
+      emitpcode (POC_RRF, pcop);
+      if (mask_mode == 2)
+        return;
+      break;
+    case 3:
+      /* load sign if needed */
+      if (mask_mode == 2)
+        emitpcode (POC_RLFW, pcop);
+      emitpcode (POC_RRF, pcop);
+      /* load sign if needed */
+      if (mask_mode == 2)
+        emitpcode (POC_RLFW, pcop);
+      emitpcode (POC_RRF, pcop);
+      /* load sign if needed */
+      if (mask_mode == 2)
+        emitpcode (POC_RLFW, pcop);
+      emitpcode (POC_RRF, pcop);
+      if (mask_mode == 2)
+        return;
+      break;
+    case 4:
+      emitpcode (POC_SWAPF, pcop);
+      break;
+    case 5:
+      emitpcode (POC_SWAPF, pcop);
+      emitpcode (POC_RRF, pcop);
+      break;
+    case 6:
+      emitpcode (POC_SWAPF, pcop);
+      emitpcode (POC_RRF, pcop);
+      emitpcode (POC_RRF, pcop);
+      break;
+    case 7:
+      if (mask_mode == 2)
+        {
+          /* load sign */
+          emitpcode (POC_RLFW, pcop);
+          emitpcode (POC_CLRF, pcop);
+          emitSKPNC;
+          emitpcode (POC_COMF, pcop);
+          return;
+        }
+      else
+        {
+          emitpcode (POC_RLFW, pcop);
+          emitpcode (POC_RLF, pcop);
+        }
+      break;
+    }
+
+  if (mask_mode == 0)
+    {
+      /* leave invalid bits undefined */
+      return;
+    }
+
+  /* clear invalid bits -- zero-extend */
+  emitpcode (POC_MOVLW, popGetLit (0x00ff >> shCount));
+  emitpcode (POC_ANDWF, pcop);
+
+  if (mask_mode == 2)
+    {
+      /* sign-extend */
+      emitpcode (POC_MOVLW, popGetLit (0x00ff << (8 - shCount)));
+      emitpcode (POC_BTFSC, newpCodeOpBit (get_op (pcop, NULL, 0), 7 - shCount, 0));
+      emitpcode (POC_IORWF, pcop);
+    }
+}
+
+/*-----------------------------------------------------------------*/
+/* movLeft2Result - move byte from left to result                  */
+/*-----------------------------------------------------------------*/
+static void
+movLeft2Result (operand * left, int offl, operand * result, int offr)
+{
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  if (!pic14_sameRegs (AOP (left), AOP (result)) || (offl != offr))
+    {
+      aopGet (AOP (left), offl, FALSE, FALSE);
+
+      emitpcode (POC_MOVFW, popGet (AOP (left), offl));
+      emitpcode (POC_MOVWF, popGet (AOP (result), offr));
+    }
+}
+
+/*-----------------------------------------------------------------*/
+/* shiftLeft_Left2ResultLit - shift left by known count            */
+/*-----------------------------------------------------------------*/
+
+static void
+shiftLeft_Left2ResultLit (operand * left, operand * result, int shCount)
+{
+  int size, same, offr, i;
+
+  size = AOP_SIZE (left);
+  if (AOP_SIZE (result) < size)
+    size = AOP_SIZE (result);
+
+  same = pic14_sameRegs (AOP (left), AOP (result));
+
+  offr = shCount / 8;
+  shCount = shCount & 0x07;
+
+  size -= offr;
+
+  switch (shCount)
+    {
+    case 0:                    /* takes 0 or 2N cycles (for offr==0) */
+      if (!same || offr)
+        {
+          for (i = size - 1; i >= 0; i--)
+            movLeft2Result (left, i, result, offr + i);
+        }                       // if
+      break;
+
+    case 1:                    /* takes 1N+1 or 2N+1 cycles (or offr==0) */
+      if (same && offr)
+        {
+          shiftLeft_Left2ResultLit (left, result, 8 * offr);
+          shiftLeft_Left2ResultLit (result, result, shCount);
+          return;               /* prevent clearing result again */
+        }
+      else
+        {
+          if (pic->isEnhancedCore)
+            {
+              for (i = 0; i < size; i++)
+                {
+                  if (same && !offr)
+                    {
+                      if (i == 0)
+                        {
+                          emitpcode (POC_LSLF, popGet (AOP (left), i));
+                        }
+                      else
+                        {
+                          emitpcode (POC_RLF, popGet (AOP (left), i));
+                        }
+                    }
+                  else
+                    {
+                      if (i == 0)
+                        {
+                          emitpcode (POC_LSLFW, popGet (AOP (left), i));
+                        }
+                      else
+                        {
+                          emitpcode (POC_RLFW, popGet (AOP (left), i));
+                        }
+
+                      emitpcode (POC_MOVWF, popGet (AOP (result), i + offr));
+                    }
+                }
+            }
+          else
+            {
+              emitCLRC;
+              for (i = 0; i < size; i++)
+                {
+                  if (same && !offr)
+                    {
+                      emitpcode (POC_RLF, popGet (AOP (left), i));
+                    }
+                  else
+                    {
+                      emitpcode (POC_RLFW, popGet (AOP (left), i));
+                      emitpcode (POC_MOVWF, popGet (AOP (result), i + offr));
+                    }           // if
+                }               // for
+            }                   // if (pic->isEnhancedCore)
+        }                       // if (same && offr)
+      break;
+
+    case 4:                    /* takes 3+5(N-1) = 5N-2 cycles (for offr==0) */
+      /* works in-place/with offr as well */
+      emitpcode (POC_SWAPFW, popGet (AOP (left), size - 1));
+      emitpcode (POC_ANDLW, popGetLit (0xF0));
+      emitpcode (POC_MOVWF, popGet (AOP (result), size - 1 + offr));
+
+      for (i = size - 2; i >= 0; i--)
+        {
+          emitpcode (POC_SWAPFW, popGet (AOP (left), i));
+          emitpcode (POC_MOVWF, popGet (AOP (result), i + offr));
+          emitpcode (POC_ANDLW, popGetLit (0x0F));
+          emitpcode (POC_IORWF, popGet (AOP (result), i + offr + 1));
+          emitpcode (POC_XORWF, popGet (AOP (result), i + offr));
+        }                       // for i
+      break;
+
+    case 7:                    /* takes 2(N-1)+3 = 2N+1 cycles */
+      /* works in-place/with offr as well */
+      emitpcode (POC_RRFW, popGet (AOP (left), size - 1));
+      for (i = size - 2; i >= 0; i--)
+        {
+          emitpcode (POC_RRFW, popGet (AOP (left), i));
+          emitpcode (POC_MOVWF, popGet (AOP (result), offr + i + 1));
+        }                       // for i
+      emitpcode (POC_CLRF, popGet (AOP (result), offr));
+      emitpcode (POC_RRF, popGet (AOP (result), offr));
+      break;
+
+    default:
+      shiftLeft_Left2ResultLit (left, result, offr * 8 + shCount - 1);
+      shiftLeft_Left2ResultLit (result, result, 1);
+      return;                   /* prevent clearing result again */
+      break;
+    }                           // switch
+
+  while (0 < offr--)
+    {
+      emitpcode (POC_CLRF, popGet (AOP (result), offr));
+    }                           // while
+}
+
+/*-----------------------------------------------------------------*/
+/* shiftRight_Left2ResultLit - shift right by known count          */
+/*-----------------------------------------------------------------*/
+
+static void
+shiftRight_Left2ResultLit (operand * left, operand * result, int shCount, int sign)
+{
+  int size, same, offr, i;
+
+  size = AOP_SIZE (left);
+  if (AOP_SIZE (result) < size)
+    size = AOP_SIZE (result);
+
+  same = pic14_sameRegs (AOP (left), AOP (result));
+
+  offr = shCount / 8;
+  shCount = shCount & 0x07;
+
+  size -= offr;
+
+  if (size)
+    {
+      switch (shCount)
+        {
+        case 0:                /* takes 0 or 2N cycles (for offr==0) */
+          if (!same || offr)
+            {
+              for (i = 0; i < size; i++)
+                movLeft2Result (left, i + offr, result, i);
+            }                   // if
+          break;
+
+        case 1:                /* takes 1N+1(3) or 2N+1(3) cycles (or offr==0) */
+          emitpComment ("%s:%d: shCount=%d, size=%d, sign=%d, same=%d, offr=%d", __FUNCTION__, __LINE__, shCount, size, sign,
+                        same, offr);
+          if (same && offr)
+            {
+              shiftRight_Left2ResultLit (left, result, 8 * offr, sign);
+              shiftRight_Left2ResultLit (result, result, shCount, sign);
+              return;           /* prevent sign-extending result again */
+            }
+          else
+            {
+              if (pic->isEnhancedCore)
+                {
+                  for (i = size - 1; i >= 0; i--)
+                    {
+                      if (same && !offr)
+                        {
+                          if (i == (size - 1))
+                            {
+                              if (sign)
+                                {
+                                  emitpcode (POC_ASRF, popGet (AOP (left), i));
+                                }
+                              else
+                                {
+                                  emitpcode (POC_LSRF, popGet (AOP (left), i));
+                                }
+                            }
+                          else
+                            {
+                              emitpcode (POC_RRF, popGet (AOP (left), i));
+                            }
+                        }
+                      else
+                        {
+                          if (i == (size - 1))
+                            {
+                              if (sign)
+                                {
+                                  emitpcode (POC_ASRFW, popGet (AOP (left), i));
+                                }
+                              else
+                                {
+                                  emitpcode (POC_LSRFW, popGet (AOP (left), i));
+                                }
+                            }
+                          else
+                            {
+                              emitpcode (POC_RRFW, popGet (AOP (left), i + offr));
+                            }
+
+                          emitpcode (POC_MOVWF, popGet (AOP (result), i));
+                        }       // if (same && !offr)
+                    }           // for i
+                }
+              else
+                {
+                  emitCLRC;
+                  if (sign)
+                    {
+                      emitpcode (POC_BTFSC, newpCodeOpBit (aopGet (AOP (left), AOP_SIZE (left) - 1, FALSE, FALSE), 7, 0));
+                      emitSETC;
+                    }
+
+                  for (i = size - 1; i >= 0; i--)
+                    {
+                      if (same && !offr)
+                        {
+                          emitpcode (POC_RRF, popGet (AOP (left), i));
+                        }
+                      else
+                        {
+                          emitpcode (POC_RRFW, popGet (AOP (left), i + offr));
+                          emitpcode (POC_MOVWF, popGet (AOP (result), i));
+                        }
+                    }           // for i
+                }               // if (pic->isEnhancedCore)  
+            }                   // if (same && offr)
+          break;
+
+        case 4:                /* takes 3(6)+5(N-1) = 5N-2(+1) cycles (for offr==0) */
+          /* works in-place/with offr as well */
+          emitpcode (POC_SWAPFW, popGet (AOP (left), offr));
+          emitpcode (POC_ANDLW, popGetLit (0x0F));
+          emitpcode (POC_MOVWF, popGet (AOP (result), 0));
+
+          for (i = 1; i < size; i++)
+            {
+              emitpcode (POC_SWAPFW, popGet (AOP (left), i + offr));
+              emitpcode (POC_MOVWF, popGet (AOP (result), i));
+              emitpcode (POC_ANDLW, popGetLit (0xF0));
+              emitpcode (POC_IORWF, popGet (AOP (result), i - 1));
+              emitpcode (POC_XORWF, popGet (AOP (result), i));
+            }                   // for i
+
+          if (sign)
+            {
+              emitpcode (POC_MOVLW, popGetLit (0xF0));
+              emitpcode (POC_BTFSC, newpCodeOpBit (aopGet (AOP (result), size - 1, FALSE, FALSE), 3, 0));
+              emitpcode (POC_IORWF, popGet (AOP (result), size - 1));
+            }                   // if
+          break;
+
+        case 7:                /* takes 2(N-1)+3(4) = 2N+1(2) cycles */
+          /* works in-place/with offr as well */
+          emitpcode (POC_RLFW, popGet (AOP (left), offr));
+          for (i = 0; i < size - 1; i++)
+            {
+              emitpcode (POC_RLFW, popGet (AOP (left), offr + i + 1));
+              emitpcode (POC_MOVWF, popGet (AOP (result), i));
+            }                   // for i
+          emitpcode (POC_CLRF, popGet (AOP (result), size - 1));
+          if (!sign)
+            {
+              emitpcode (POC_RLF, popGet (AOP (result), size - 1));
+            }
+          else
+            {
+              emitSKPNC;
+              emitpcode (POC_DECF, popGet (AOP (result), size - 1));
+            }
+          break;
+
+        default:
+          shiftRight_Left2ResultLit (left, result, offr * 8 + shCount - 1, sign);
+          shiftRight_Left2ResultLit (result, result, 1, sign);
+          return;               /* prevent sign extending result again */
+          break;
+        }                       // switch
+    }                           // if
+
+  addSign (result, size, sign);
+}
+
+/*-----------------------------------------------------------------*
+* genMultiAsm - repeat assembly instruction for size of register.
+* if endian == 1, then the high byte (i.e base address + size of
+* register) is used first else the low byte is used first;
+*-----------------------------------------------------------------*/
+static void
+genMultiAsm (PIC_OPCODE poc, operand * reg, int size, int endian)
+{
+
+  int offset = 0;
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+  if (!reg)
+    return;
+
+  if (!endian)
+    {
+      endian = 1;
+    }
+  else
+    {
+      endian = -1;
+      offset = size - 1;
+    }
+
+  while (size--)
+    {
+      emitpcode (poc, popGet (AOP (reg), offset));
+      offset += endian;
+    }
+
+}
+
+/*-----------------------------------------------------------------*/
+/* loadSignToC - load the operand's sign bit into CARRY            */
+/*-----------------------------------------------------------------*/
+
+static void
+loadSignToC (operand * op)
+{
+  FENTRY;
+  assert (op && AOP (op) && AOP_SIZE (op));
+
+  emitCLRC;
+  emitpcode (POC_BTFSC, newpCodeOpBit (aopGet (AOP (op), AOP_SIZE (op) - 1, FALSE, FALSE), 7, 0));
+  emitSETC;
+}
+
+/*-----------------------------------------------------------------*/
+/* genRightShift - generate code for right shifting                */
+/*-----------------------------------------------------------------*/
+static void
+genGenericShift (iCode * ic, int shiftRight)
+{
+  operand *right, *left, *result;
+  int size;
+  symbol *tlbl, *tlbl1, *inverselbl;
+
+  FENTRY;
+  /* if signed then we do it the hard way preserve the
+     sign bit moving it inwards */
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+  /* signed & unsigned types are treated the same : i.e. the
+     signed is NOT propagated inwards : quoting from the
+     ANSI - standard : "for E1 >> E2, is equivalent to division
+     by 2**E2 if unsigned or if it has a non-negative value,
+     otherwise the result is implementation defined ", MY definition
+     is that the sign does not get propagated */
+
+  right = IC_RIGHT (ic);
+  left = IC_LEFT (ic);
+  result = IC_RESULT (ic);
+
+  aopOp (right, ic, FALSE);
+  aopOp (left, ic, FALSE);
+  aopOp (result, ic, FALSE);
+
+  /* if the shift count is known then do it
+     as efficiently as possible */
+  if (AOP_TYPE (right) == AOP_LIT)
+    {
+      int lit = (int) ulFromVal (AOP (right)->aopu.aop_lit);
+      if (lit < 0)
+        {
+          lit = -lit;
+          shiftRight = !shiftRight;
+        }
+
+      if (shiftRight)
+        shiftRight_Left2ResultLit (left, result, lit, !SPEC_USIGN (operandType (left)));
+      else
+        shiftLeft_Left2ResultLit (left, result, lit);
+      //genRightShiftLiteral (left,right,result,ic, 0);
+      return;
+    }
+
+  /* shift count is unknown then we have to form
+     a loop get the loop count in B : Note: we take
+     only the lower order byte since shifting
+     more that 32 bits make no sense anyway, ( the
+     largest size of an object can be only 32 bits ) */
+
+  /* we must not overwrite the shift counter */
+  assert (!pic14_sameRegs (AOP (right), AOP (result)));
+
+  /* now move the left to the result if they are not the
+     same */
+  if (!pic14_sameRegs (AOP (left), AOP (result)))
+    {
+      size = min (AOP_SIZE (result), AOP_SIZE (left));
+      while (size--)
+        {
+          mov2w (AOP (left), size);
+          movwf (AOP (result), size);
+        }
+      addSign (result, AOP_SIZE (left), !SPEC_USIGN (operandType (left)));
+    }
+
+  tlbl = newiTempLabel (NULL);
+  tlbl1 = newiTempLabel (NULL);
+  inverselbl = NULL;
+  size = AOP_SIZE (result);
+
+  mov2w (AOP (right), 0);
+  if (!SPEC_USIGN (operandType (right)))
+    {
+      inverselbl = newiTempLabel (NULL);
+      /* signed shift count -- invert shift direction for c<0 */
+      emitpcode (POC_BTFSC, newpCodeOpBit (aopGet (AOP (right), 0, FALSE, FALSE), 7, 0));
+      emitpcode (POC_GOTO, popGetLabel (inverselbl->key));
+    }                           // if
+  emitpcode (POC_SUBLW, popGetLit (0)); /* -count in WREG, 0-x > 0 --> BORROW = !CARRY --> CARRY is clear! */
+  /* check for `a = b >> c' with `-c == 0' */
+  emitSKPNZ;
+  emitpcode (POC_GOTO, popGetLabel (tlbl1->key));
+  emitpLabel (tlbl->key);
+  /* propagate the sign bit inwards for SIGNED result */
+  if (shiftRight && !SPEC_USIGN (operandType (result)))
+    loadSignToC (result);
+  genMultiAsm (shiftRight ? POC_RRF : POC_RLF, result, size, shiftRight);
+  emitpcode (POC_ADDLW, popGetLit (1)); /* clears CARRY (unless W==0 afterwards) */
+  emitSKPC;
+  emitpcode (POC_GOTO, popGetLabel (tlbl->key));
+
+  if (!SPEC_USIGN (operandType (right)))
+    {
+      symbol *inv_loop = newiTempLabel (NULL);
+
+      shiftRight = !shiftRight; /* invert shift direction */
+
+      /* we came here from the code above -- we are done */
+      emitpcode (POC_GOTO, popGetLabel (tlbl1->key));
+
+      /* emit code for shifting N<0 steps, count is already in W */
+      emitpLabel (inverselbl->key);
+      if (!shiftRight || SPEC_USIGN (operandType (result)))
+        emitCLRC;
+      emitpLabel (inv_loop->key);
+      /* propagate the sign bit inwards for SIGNED result */
+      if (shiftRight && !SPEC_USIGN (operandType (result)))
+        loadSignToC (result);
+      genMultiAsm (shiftRight ? POC_RRF : POC_RLF, result, size, shiftRight);
+      emitpcode (POC_ADDLW, popGetLit (1));
+      emitSKPC;
+      emitpcode (POC_GOTO, popGetLabel (inv_loop->key));
+    }                           // if
+
+  emitpLabel (tlbl1->key);
+
+  freeAsmop (left, NULL, ic, TRUE);
+  freeAsmop (right, NULL, ic, TRUE);
+  freeAsmop (result, NULL, ic, TRUE);
+}
+
+static void
+genRightShift (iCode * ic)
+{
+  genGenericShift (ic, 1);
+}
+
+static void
+genLeftShift (iCode * ic)
+{
+  genGenericShift (ic, 0);
+}
+
+/*-----------------------------------------------------------------*/
+/* SetIrp - Set IRP bit                                            */
+/*-----------------------------------------------------------------*/
+static void
+SetIrp (operand * result)
+{
+  FENTRY;
+  if (AOP_TYPE (result) == AOP_LIT)
+    {
+      unsigned lit = (unsigned) double2ul (operandLitValue (result));
+      if (lit & 0x100)
+        emitSETIRP;
+      else
+        emitCLRIRP;
+    }
+  else if ((AOP_TYPE (result) == AOP_PCODE) && (AOP (result)->aopu.pcop->type == PO_LITERAL))
+    {
+      int addrs = PCOL (AOP (result)->aopu.pcop)->lit;
+      if (addrs & 0x100)
+        emitSETIRP;
+      else
+        emitCLRIRP;
+    }
+  else if ((AOP_TYPE (result) == AOP_PCODE) && (AOP (result)->aopu.pcop->type == PO_IMMEDIATE))
+    {
+      emitCLRIRP;           /* always ensure this is clear as it may have previously been set */
+      emitpcode (POC_MOVLW, popGetAddr (AOP (result), 1, 0));
+      emitpcode (POC_ANDLW, popGetLit (0x01));
+      emitSKPZ;
+      emitSETIRP;
+    }
+  else
+    {
+      emitCLRIRP;           /* always ensure this is clear as it may have previouly been set */
+      if (AOP_SIZE (result) > 1)
+        {
+          emitpcode (POC_BTFSC, newpCodeOpBit (aopGet (AOP (result), 1, FALSE, FALSE), 0, 0));
+          emitSETIRP;
+        }
+    }
+}
+
+static void
+setup_fsr (operand * ptr)
+{
+  if (pic->isEnhancedCore)
+    {
+      mov2w_op (ptr, 0);
+      emitpcode (POC_MOVWF, popCopyReg (&pc_fsr0l));
+      mov2w_op (ptr, 1);
+      emitpcode (POC_MOVWF, popCopyReg (&pc_fsr0h));
+    }
+  else
+    {
+      mov2w_op (ptr, 0);
+      emitpcode (POC_MOVWF, popCopyReg (&pc_fsr));
+
+      /* also setup-up IRP */
+      SetIrp (ptr);
+    }
+}
+
+static void
+inc_fsr (int delta)
+{
+  if (0 == delta)
+    {
+      /* Nothing to do. */
+      return;
+    } // if
+
+  if (pic->isEnhancedCore)
+    {
+      if (pic14_options.no_ext_instr)
+        {
+          /*
+           * Not sure if we may modify W here, so implement this without
+           * touching W.
+           *
+           * Efficiency is not too important here, as enhanced cores
+           * will most likely use extended instructions here. This is
+           * only a workaround for gputils 0.13.7, which supports the
+           * 16f1934 enhanced core, but fails to assemble ADDFSR.
+           */
+          while (delta > 0)
+            {
+              emitpcode (POC_INCFSZ, popCopyReg (&pc_fsr0l));
+              emitpcode (POC_DECF, popCopyReg (&pc_fsr0h));
+              emitpcode (POC_INCF, popCopyReg (&pc_fsr0h));
+              --delta;
+            } // while
+          while (delta < 0)
+            {
+              addpCode2pBlock (pb, newpCodeAsmDir("MOVF", "FSR0L, 1"));
+              emitSKPNZ;
+              emitpcode (POC_DECF, popCopyReg (&pc_fsr0h));
+              emitpcode (POC_DECF, popCopyReg (&pc_fsr0l));
+              ++delta;
+            } // while
+        }
+      else
+        {
+          assert (delta >= -32);
+          assert (delta < 32);
+          /* Hack: Turn this into a PCI (not that easy due to the argument structure). */
+          addpCode2pBlock (pb, newpCodeAsmDir ("ADDFSR", "FSR0, %d", delta));
+        } // if
+    }
+  else
+    {
+      while (delta > 0)
+        {
+          emitpcode (POC_INCF, popCopyReg (&pc_fsr));
+          --delta;
+        } // while
+      while (delta < 0)
+        {
+          emitpcode (POC_DECF, popCopyReg (&pc_fsr));
+          ++delta;
+        } // while
+    } // if
+}
+
+/*-----------------------------------------------------------------*/
+/* emitPtrByteGet - emits code to get a byte into WREG from an     */
+/*                  arbitrary pointer (__code, __data, generic)    */
+/*-----------------------------------------------------------------*/
+static void
+emitPtrByteGet (operand * src, int p_type, bool alreadyAddressed)
+{
+  FENTRY;
+  switch (p_type)
+    {
+    case POINTER:
+    case FPOINTER:
+      if (!alreadyAddressed)
+        setup_fsr (src);
+      emitpcode (POC_MOVFW, popCopyReg (pc_indf));
+      break;
+
+    case CPOINTER:
+      assert (AOP_SIZE (src) == 2);
+      mov2w_op (src, 0);
+      emitpcode (POC_MOVWF, popRegFromIdx (Gstack_base_addr - 1));
+      mov2w_op (src, 1);
+      emitpcode (POC_MOVWF, popRegFromIdx (Gstack_base_addr));
+      emitpcode (POC_MOVLW, popGetLit (GPTRTAG_CODE));  /* GPOINTER tag for __code space */
+      call_libraryfunc ("__gptrget1");
+      break;
+
+    case GPOINTER:
+      assert (AOP_SIZE (src) == 3);
+      mov2w_op (src, 0);
+      emitpcode (POC_MOVWF, popRegFromIdx (Gstack_base_addr - 1));
+      mov2w_op (src, 1);
+      emitpcode (POC_MOVWF, popRegFromIdx (Gstack_base_addr));
+      mov2w_op (src, 2);
+      call_libraryfunc ("__gptrget1");
+      break;
+
+    default:
+      assert (!"unhandled pointer type");
+      break;
+    }
+}
+
+/*-----------------------------------------------------------------*/
+/* emitPtrByteSet - emits code to set a byte from src through a    */
+/* pointer register INDF (legacy 8051 uses R0, R1, or DPTR).       */
+/*-----------------------------------------------------------------*/
+static void
+emitPtrByteSet (operand * dst, int p_type, bool alreadyAddressed)
+{
+  FENTRY;
+  switch (p_type)
+    {
+    case POINTER:
+    case FPOINTER:
+      if (!alreadyAddressed)
+        setup_fsr (dst);
+      emitpcode (POC_MOVWF, popCopyReg (pc_indf));
+      break;
+
+    case CPOINTER:
+      assert (!"trying to assign to __code pointer");
+      break;
+
+    case GPOINTER:
+      emitpcode (POC_MOVWF, popRegFromIdx (Gstack_base_addr - 2));
+      mov2w_op (dst, 0);
+      emitpcode (POC_MOVWF, popRegFromIdx (Gstack_base_addr - 1));
+      mov2w_op (dst, 1);
+      emitpcode (POC_MOVWF, popRegFromIdx (Gstack_base_addr));
+      mov2w_op (dst, 2);
+      call_libraryfunc ("__gptrput1");
+      break;
+
+    default:
+      assert (!"unhandled pointer type");
+      break;
+    }
+}
+
+/*-----------------------------------------------------------------*/
+/* genUnpackBits - generates code for unpacking bits               */
+/*-----------------------------------------------------------------*/
+static void
+genUnpackBits (operand * result, operand * left, int ptype, iCode * ifx)
+{
+  sym_link *etype;              /* bitfield type information */
+  unsigned blen;                /* bitfield length */
+  unsigned bstr;                /* bitfield starting bit within byte */
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  etype = getSpec (operandType (result));
+  blen = SPEC_BLEN (etype);
+  bstr = SPEC_BSTR (etype);
+
+  /* single bit field case */
+  if (blen == 1)
+    {
+      if (ifx)
+        {
+          /* that is for an if statement */
+          pCodeOp *pcop;
+          resolvedIfx rIfx;
+
+          resolveIfx (&rIfx, ifx);
+          if (ptype == -1)      /* direct */
+            pcop = newpCodeOpBit (aopGet (AOP (left), 0, FALSE, FALSE), bstr, 0);
+          else
+            {
+              setup_fsr (left);
+              pcop = newpCodeOpBit (pc_indf->pcop.name, bstr, 0);
+            }
+          emitpcode ((rIfx.condition) ? POC_BTFSC : POC_BTFSS, pcop);
+          emitpcode (POC_GOTO, popGetLabel (rIfx.lbl->key));
+          ifx->generated = TRUE;
+        }
+      else
+        {
+          /*
+           * In case of a volatile bitfield read such as
+           * (void)PORTCbits.RC3;
+           * we end up having no result ...
+           */
+          int haveResult = !!AOP_SIZE(result);
+
+          if (haveResult)
+            {
+              assert (!pic14_sameRegs (AOP (result), AOP (left)));
+              emitpcode (POC_CLRF, popGet (AOP (result), 0));
+            } // if
+
+          switch (ptype)
+            {
+            case -1:
+                emitpcode (POC_BTFSC, newpCodeOpBit (aopGet (AOP (left), 0, FALSE, FALSE), bstr, 0));
+                /* If haveResult, adjust result below, otherwise: */
+                if (!haveResult)
+                  {
+                    /* Dummy instruction to allow bit-test above (volatile dummy bitfield read). */
+                    emitpcode (POC_MOVLW, popGetLit (0));
+                  } // if
+              break;
+
+            case POINTER:
+            case FPOINTER:
+            case GPOINTER:
+            case CPOINTER:
+              emitPtrByteGet (left, ptype, FALSE);
+              if (haveResult)
+                {
+                  emitpcode (POC_ANDLW, popGetLit (1UL << bstr));
+                  emitSKPZ;
+                  /* adjust result below */
+                } // if
+              break;
+
+            default:
+              assert (!"unhandled pointer type");
+            }                   // switch
+
+          /* move sign-/zero extended bit to result */
+          if (haveResult)
+            {
+              if (SPEC_USIGN (OP_SYM_ETYPE (left)))
+                emitpcode (POC_INCF, popGet (AOP (result), 0));
+              else
+                emitpcode (POC_DECF, popGet (AOP (result), 0));
+              addSign (result, 1, !SPEC_USIGN (OP_SYM_ETYPE (left)));
+            } // if
+        }
+      return;
+    }
+  else if (blen <= 8 && ((blen + bstr) <= 8))
+    {
+      /* blen > 1 */
+      int i;
+
+      for (i = 0; i < AOP_SIZE (result); i++)
+        emitpcode (POC_CLRF, popGet (AOP (result), i));
+
+      switch (ptype)
+        {
+        case -1:
+          mov2w (AOP (left), 0);
+          break;
+
+        case POINTER:
+        case FPOINTER:
+        case GPOINTER:
+        case CPOINTER:
+          emitPtrByteGet (left, ptype, FALSE);
+          break;
+
+        default:
+          assert (!"unhandled pointer type");
+        }                       // switch
+
+      if (blen < 8)
+        emitpcode (POC_ANDLW, popGetLit ((((1UL << blen) - 1) << bstr) & 0x00ff));
+      movwf (AOP (result), 0);
+      AccRsh (popGet (AOP (result), 0), bstr, 1);       /* zero extend the bitfield */
+
+      if (!SPEC_USIGN (OP_SYM_ETYPE (left)) && (bstr + blen != 8))
+        {
+          /* signed bitfield */
+          assert (bstr + blen > 0);
+          emitpcode (POC_MOVLW, popGetLit (0x00ff << (bstr + blen)));
+          emitpcode (POC_BTFSC, newpCodeOpBit (aopGet (AOP (result), 0, FALSE, FALSE), bstr + blen - 1, 0));
+          emitpcode (POC_IORWF, popGet (AOP (result), 0));
+        }
+      addSign (result, 1, !SPEC_USIGN (OP_SYM_ETYPE (left)));
+      return;
+    }
+
+  assert (!"bitfields larger than 8 bits or crossing byte boundaries are not yet supported");
+}
+
+#if 1
+/*-----------------------------------------------------------------*/
+/* genDataPointerGet - generates code when ptr offset is known     */
+/*-----------------------------------------------------------------*/
+static void
+genDataPointerGet (operand * left, operand * result, iCode * ic)
+{
+  unsigned int size;
+  int offset = 0;
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+
+  /* optimization - most of the time, left and result are the same
+   * address, but different types. for the pic code, we could omit
+   * the following
+   */
+  aopOp (result, ic, TRUE);
+
+  if (pic14_sameRegs (AOP (left), AOP (result)))
+    return;
+
+  DEBUGpic14_AopType (__LINE__, left, NULL, result);
+
+  //emitpcode(POC_MOVFW, popGet(AOP(left),0));
+
+  size = AOP_SIZE (result);
+  if (size > getSize (OP_SYM_ETYPE (left)))
+    size = getSize (OP_SYM_ETYPE (left));
+
+  offset = 0;
+  while (size--)
+    {
+      emitpcode (POC_MOVFW, popGet (AOP (left), offset));
+      emitpcode (POC_MOVWF, popGet (AOP (result), offset));
+      offset++;
+    }
+
+  freeAsmop (left, NULL, ic, TRUE);
+  freeAsmop (result, NULL, ic, TRUE);
+}
+#endif
+
+/*-----------------------------------------------------------------*/
+/* genNearPointerGet - pic14_emitcode for near pointer fetch       */
+/*-----------------------------------------------------------------*/
+static void
+genNearPointerGet (operand * left, operand * result, iCode * ic)
+{
+  asmop *aop = NULL;
+  sym_link *ltype = operandType (left);
+  sym_link *rtype = operandType (result);
+  sym_link *retype = getSpec (rtype);   /* bitfield type information */
+  int direct = 0;
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+
+  aopOp (left, ic, FALSE);
+
+  /* if left is rematerialisable and
+     result is not bit variable type and
+     the left is pointer to data space i.e
+     lower 128 bytes of space */
+  if (AOP_TYPE (left) == AOP_PCODE &&   //AOP_TYPE(left) == AOP_IMMD &&
+      !IS_BITVAR (retype) && PIC_IS_DATA_PTR (ltype))
+    {
+      genDataPointerGet (left, result, ic);
+      return;
+    }
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  aopOp (result, ic, FALSE);
+
+  /* Check if can access directly instead of via a pointer */
+  if ((AOP_TYPE (left) == AOP_PCODE) && (AOP (left)->aopu.pcop->type == PO_IMMEDIATE) && (AOP_SIZE (result) <= 1))
+    {
+      direct = 1;
+    }
+
+  if (IS_BITFIELD (getSpec (operandType (result))))
+    {
+      genUnpackBits (result, left, direct ? -1 : POINTER, ifxForOp (IC_RESULT (ic), ic));
+      goto release;
+    }
+
+  /* If the pointer value is not in a the FSR then need to put it in */
+  /* Must set/reset IRP bit for use with FSR. */
+  if (!direct)
+    setup_fsr (left);
+
+//  sym_link *etype;
+  /* if bitfield then unpack the bits */
+  {
+    /* we have can just get the values */
+    int size = AOP_SIZE (result);
+    int offset = 0;
+
+    DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+    while (size--)
+      {
+        if (direct)
+          emitpcode (POC_MOVWF, popGet (AOP (left), 0));
+        else
+          emitpcode (POC_MOVFW, popCopyReg (pc_indf));
+        if (AOP_TYPE (result) == AOP_LIT)
+          {
+            emitpcode (POC_MOVLW, popGet (AOP (result), offset));
+          }
+        else
+          {
+            emitpcode (POC_MOVWF, popGet (AOP (result), offset));
+          }
+        if (size && !direct)
+          {
+            inc_fsr (1);
+          }
+        offset++;
+      }
+  }
+
+  /* now some housekeeping stuff */
+  if (aop)
+    {
+      /* we had to allocate for this iCode */
+      DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+      freeAsmop (NULL, aop, ic, TRUE);
+    }
+  else if (!direct)
+    {
+      /* nothing to do */
+    }
+  else
+    {
+      /* we did not allocate which means left
+         already in a pointer register, then
+         if size > 0 && this could be used again
+         we have to point it back to where it
+         belongs */
+      DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+      if (AOP_SIZE (result) > 1 && !OP_SYMBOL (left)->remat && (OP_SYMBOL (left)->liveTo > ic->seq || ic->depth))
+        {
+          int size = AOP_SIZE (result) - 1;
+          inc_fsr (-size);
+        }
+    }
+
+release:
+  /* done */
+  freeAsmop (left, NULL, ic, TRUE);
+  freeAsmop (result, NULL, ic, TRUE);
+
+}
+
+/*-----------------------------------------------------------------*/
+/* genGenPointerGet - gget value from generic pointer space        */
+/*-----------------------------------------------------------------*/
+static void
+genGenPointerGet (operand * left, operand * result, iCode * ic)
+{
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  aopOp (left, ic, FALSE);
+  aopOp (result, ic, FALSE);
+
+
+  DEBUGpic14_AopType (__LINE__, left, NULL, result);
+
+  if (IS_BITFIELD (getSpec (operandType (result))))
+    {
+      genUnpackBits (result, left, GPOINTER, ifxForOp (IC_RESULT (ic), ic));
+      return;
+    }
+
+  {
+    /* emit call to __gptrget */
+    char *func[] = { NULL, "__gptrget1", "__gptrget2", "__gptrget3", "__gptrget4" };
+    int size = AOP_SIZE (result);
+    int idx = 0;
+
+    assert (size > 0 && size <= 4);
+
+    /* pass arguments */
+    assert (AOP_SIZE (left) == 3);
+    mov2w (AOP (left), 0);
+    emitpcode (POC_MOVWF, popRegFromIdx (Gstack_base_addr - 1));
+    mov2w (AOP (left), 1);
+    emitpcode (POC_MOVWF, popRegFromIdx (Gstack_base_addr));
+    mov2w (AOP (left), 2);
+    call_libraryfunc (func[size]);
+
+    /* save result */
+    movwf (AOP (result), --size);
+    while (size--)
+      {
+        emitpcode (POC_MOVFW, popRegFromIdx (Gstack_base_addr - idx++));
+        movwf (AOP (result), size);
+      }                         // while
+  }
+
+  freeAsmop (left, NULL, ic, TRUE);
+  freeAsmop (result, NULL, ic, TRUE);
+
+}
+
+/*-----------------------------------------------------------------*/
+/* genConstPointerGet - get value from const generic pointer space */
+/*-----------------------------------------------------------------*/
+static void
+genConstPointerGet (operand * left, operand * result, iCode * ic)
+{
+  //sym_link *retype = getSpec(operandType(result));
+#if 0
+  symbol *albl, *blbl;          //, *clbl;
+  pCodeOp *pcop;
+#endif
+  int i, lit;
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  aopOp (left, ic, FALSE);
+  aopOp (result, ic, FALSE);
+
+  DEBUGpic14_AopType (__LINE__, left, NULL, result);
+
+  DEBUGpic14_emitcode ("; ", " %d getting const pointer", __LINE__);
+
+  lit = op_isLitLike (left);
+
+  if (IS_BITFIELD (getSpec (operandType (result))))
+    {
+      genUnpackBits (result, left, lit ? -1 : CPOINTER, ifxForOp (IC_RESULT (ic), ic));
+      goto release;
+    }
+
+  {
+    char *func[] = { NULL, "__gptrget1", "__gptrget2", "__gptrget3", "__gptrget4" };
+    int size = AOP_SIZE (result);
+    assert (size > 0 && size <= 4);
+
+    mov2w_op (left, 0);
+    emitpcode (POC_MOVWF, popRegFromIdx (Gstack_base_addr - 1));
+    mov2w_op (left, 1);
+    emitpcode (POC_MOVWF, popRegFromIdx (Gstack_base_addr));
+    emitpcode (POC_MOVLW, popGetLit (GPTRTAG_CODE));    /* GPOINTER tag for __code space */
+    call_libraryfunc (func[size]);
+
+    movwf (AOP (result), size - 1);
+    for (i = 1; i < size; i++)
+      {
+        emitpcode (POC_MOVFW, popRegFromIdx (Gstack_base_addr + 1 - i));
+        movwf (AOP (result), size - 1 - i);
+      }                         // for
+  }
+
+release:
+  freeAsmop (left, NULL, ic, TRUE);
+  freeAsmop (result, NULL, ic, TRUE);
+
+}
+
+/*-----------------------------------------------------------------*/
+/* genPointerGet - generate code for pointer get                   */
+/*-----------------------------------------------------------------*/
+static void
+genPointerGet (iCode * ic)
+{
+  operand *left, *result;
+  sym_link *type, *etype;
+  int p_type = -1;
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+  left = IC_LEFT (ic);
+  result = IC_RESULT (ic);
+
+  /* depending on the type of pointer we need to
+     move it to the correct pointer register */
+  type = operandType (left);
+  etype = getSpec (type);
+
+  if (IS_PTR_CONST (type))
+    DEBUGpic14_emitcode ("; ***", "%d - const pointer", __LINE__);
+
+  /* if left is of type of pointer then it is simple */
+  if (IS_PTR (type) && !IS_FUNC (type->next))
+    p_type = DCL_TYPE (type);
+  else
+    {
+      /* we have to go by the storage class */
+      p_type = PTR_TYPE (SPEC_OCLS (etype));
+
+      DEBUGpic14_emitcode ("; ***", "%d - resolve pointer by storage class", __LINE__);
+
+      if (SPEC_OCLS (etype)->codesp)
+        {
+          DEBUGpic14_emitcode ("; ***", "%d - cpointer", __LINE__);
+          //p_type = CPOINTER ;
+        }
+      else if (SPEC_OCLS (etype)->fmap && !SPEC_OCLS (etype)->paged)
+        DEBUGpic14_emitcode ("; ***", "%d - fpointer", __LINE__);
+      /*p_type = FPOINTER ; */
+      else if (SPEC_OCLS (etype)->fmap && SPEC_OCLS (etype)->paged)
+        DEBUGpic14_emitcode ("; ***", "%d - ppointer", __LINE__);
+      /*        p_type = PPOINTER; */
+      else if (SPEC_OCLS (etype) == idata)
+        DEBUGpic14_emitcode ("; ***", "%d - ipointer", __LINE__);
+      /*      p_type = IPOINTER; */
+      else
+        DEBUGpic14_emitcode ("; ***", "%d - pointer", __LINE__);
+      /*      p_type = POINTER ; */
+    }
+
+  /* now that we have the pointer type we assign
+     the pointer values */
+  switch (p_type)
+    {
+
+    case POINTER:
+    case FPOINTER:
+      //case IPOINTER:
+      genNearPointerGet (left, result, ic);
+      break;
+      /*
+         case PPOINTER:
+         genPagedPointerGet(left,result,ic);
+         break;
+
+         case FPOINTER:
+         genFarPointerGet (left,result,ic);
+         break;
+       */
+    case CPOINTER:
+      genConstPointerGet (left, result, ic);
+      break;
+
+    case GPOINTER:
+      genGenPointerGet (left, result, ic);
+      break;
+    default:
+      assert (!"unhandled pointer type");
+      break;
+    }
+
+}
+
+/*-----------------------------------------------------------------*/
+/* genPackBits - generates code for packed bit storage             */
+/*-----------------------------------------------------------------*/
+static void
+genPackBits (sym_link * etype, operand * result, operand * right, int p_type)
+{
+  unsigned blen;                /* bitfield length */
+  unsigned bstr;                /* bitfield starting bit within byte */
+  int litval;                   /* source literal value (if AOP_LIT) */
+  unsigned char mask;           /* bitmask within current byte */
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+  blen = SPEC_BLEN (etype);
+  bstr = SPEC_BSTR (etype);
+
+  /* If the bitfield length is less than a byte and does not cross byte boundaries */
+  if ((blen <= 8) && ((bstr + blen) <= 8))
+    {
+      mask = ((unsigned char) (0xFF << (blen + bstr)) | (unsigned char) (0xFF >> (8 - bstr)));
+
+      if (AOP_TYPE (right) == AOP_LIT)
+        {
+          /* Case with a bitfield length <8 and literal source */
+          int lit = (int) ulFromVal (AOP (right)->aopu.aop_lit);
+          if (blen == 1)
+            {
+              pCodeOp *pcop;
+
+              switch (p_type)
+                {
+                case -1:
+                  if (AOP (result)->type == AOP_PCODE)
+                    pcop = newpCodeOpBit (aopGet (AOP (result), 0, FALSE, FALSE), bstr, 0);
+                  else
+                    pcop = popGet (AOP (result), 0);
+                  emitpcode (lit ? POC_BSF : POC_BCF, pcop);
+                  break;
+
+                case POINTER:
+                case FPOINTER:
+                  setup_fsr (result);
+                  emitpcode (lit ? POC_BSF : POC_BCF, newpCodeOpBit (PCOP (pc_indf)->name, bstr, 0));
+                  break;
+
+                case CPOINTER:
+                  assert (!"trying to assign to bitfield via pointer to __code space");
+                  break;
+
+                case GPOINTER:
+                  emitPtrByteGet (result, p_type, FALSE);
+                  if (lit)
+                    {
+                      emitpcode (POC_IORLW, newpCodeOpLit (1UL << bstr));
+                    }
+                  else
+                    {
+                      emitpcode (POC_ANDLW, newpCodeOpLit ((~(1UL << bstr)) & 0x0ff));
+                    }
+                  emitPtrByteSet (result, p_type, TRUE);
+                  break;
+
+                default:
+                  assert (!"unhandled pointer type");
+                  break;
+                }               // switch (p_type)
+            }
+          else
+            {
+              /* blen > 1 */
+              litval = lit << bstr;
+              litval &= (~mask) & 0x00ff;
+
+              switch (p_type)
+                {
+                case -1:
+                  mov2w (AOP (result), 0);
+                  if ((litval | mask) != 0x00ff)
+                    emitpcode (POC_ANDLW, popGetLit (mask));
+                  if (litval != 0x00)
+                    emitpcode (POC_IORLW, popGetLit (litval));
+                  movwf (AOP (result), 0);
+                  break;
+
+                case POINTER:
+                case FPOINTER:
+                case GPOINTER:
+                  emitPtrByteGet (result, p_type, FALSE);
+                  if ((litval | mask) != 0x00ff)
+                    emitpcode (POC_ANDLW, popGetLit (mask));
+                  if (litval != 0x00)
+                    emitpcode (POC_IORLW, popGetLit (litval));
+                  emitPtrByteSet (result, p_type, TRUE);
+                  break;
+
+                case CPOINTER:
+                  assert (!"trying to assign to bitfield via pointer to __code space");
+                  break;
+
+                default:
+                  assert (!"unhandled pointer type");
+                  break;
+                }               // switch
+            }                   // if (blen > 1)
+        }
+      else
+        {
+          /* right is no literal */
+          if (blen == 1)
+            {
+              switch (p_type)
+                {
+                case -1:
+                  /* Note more efficient code, of pre clearing bit then only setting it if required,
+                   * can only be done if it is known that the result is not a SFR */
+                  emitpcode (POC_RRFW, popGet (AOP (right), 0));
+                  emitSKPC;
+                  emitpcode (POC_BCF, newpCodeOpBit (aopGet (AOP (result), 0, FALSE, FALSE), bstr, 0));
+                  emitSKPNC;
+                  emitpcode (POC_BSF, newpCodeOpBit (aopGet (AOP (result), 0, FALSE, FALSE), bstr, 0));
+                  break;
+
+                case POINTER:
+                case FPOINTER:
+                case GPOINTER:
+                  emitPtrByteGet (result, p_type, FALSE);
+                  emitpcode (POC_BTFSS, newpCodeOpBit (aopGet (AOP (right), 0, FALSE, FALSE), bstr, 0));
+                  emitpcode (POC_ANDLW, newpCodeOpLit (~(1UL << bstr) & 0x0ff));
+                  emitpcode (POC_BTFSC, newpCodeOpBit (aopGet (AOP (right), 0, FALSE, FALSE), bstr, 0));
+                  emitpcode (POC_IORLW, newpCodeOpLit ((1UL << bstr) & 0x0ff));
+                  emitPtrByteSet (result, p_type, TRUE);
+                  break;
+
+                case CPOINTER:
+                  assert (!"trying to assign to bitfield via pointer to __code space");
+                  break;
+
+                default:
+                  assert (!"unhandled pointer type");
+                  break;
+                }               // switch
+              return;
+            }
+          else
+            {
+              /* Case with a bitfield 1 < length <= 8 and arbitrary source */
+              pCodeOp *temp = popGetTempReg ();
+
+              mov2w (AOP (right), 0);
+              if (blen < 8)
+                {
+                  emitpcode (POC_ANDLW, popGetLit ((1UL << blen) - 1));
+                }
+              emitpcode (POC_MOVWF, temp);
+              if (bstr)
+                {
+                  AccLsh (temp, bstr);
+                }
+
+              switch (p_type)
+                {
+                case -1:
+                  mov2w (AOP (result), 0);
+                  emitpcode (POC_ANDLW, popGetLit (mask));
+                  emitpcode (POC_IORFW, temp);
+                  movwf (AOP (result), 0);
+                  break;
+
+                case POINTER:
+                case FPOINTER:
+                case GPOINTER:
+                  emitPtrByteGet (result, p_type, FALSE);
+                  emitpcode (POC_ANDLW, popGetLit (mask));
+                  emitpcode (POC_IORFW, temp);
+                  emitPtrByteSet (result, p_type, TRUE);
+                  break;
+
+                case CPOINTER:
+                  assert (!"trying to assign to bitfield via pointer to __code space");
+                  break;
+
+                default:
+                  assert (!"unhandled pointer type");
+                  break;
+                }               // switch
+
+              popReleaseTempReg (temp);
+            }                   // if (blen > 1)
+        }                       // if (AOP(right)->type != AOP_LIT)
+      return;
+    }                           // if (blen <= 8 && ((blen + bstr) <= 8))
+
+  assert (!"bitfields larger than 8 bits or crossing byte boundaries are not yet supported");
+}
+
+/*-----------------------------------------------------------------*/
+/* genDataPointerSet - remat pointer to data space                 */
+/*-----------------------------------------------------------------*/
+static void
+genDataPointerSet (operand * right, operand * result, iCode * ic)
+{
+  int size = 0;
+  int offset = 0;
+  sym_link *rtype = operandType(right);
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  aopOp (right, ic, FALSE);
+  aopOp (result, ic, FALSE);
+
+  assert (IS_SYMOP (result));
+  assert (IS_PTR (OP_SYM_TYPE (result)));
+
+  /*
+   * Determine size from right operand (not result):
+   * The result might be a rematerialized pointer to (the first field in) a struct,
+   * which then assumes the type (and size) of the struct rather than the first field.
+   */
+  size = AOP_SIZE(right);
+
+  /*test the right operand has a pointer value*/
+  if ((AOP_TYPE(right) == AOP_PCODE) && PIC_IS_DATA_PTR(rtype))
+  {
+    while (size--)
+    {
+      emitpcode(POC_MOVLW, popGetAddr(AOP(right), size, 0));
+      emitpcode(POC_MOVWF, popGet(AOP(result), size));
+    }
+  }
+  else
+  {
+    // tsd, was l+1 - the underline `_' prefix was being stripped
+    while (size--)
+    {
+      emitpComment ("%s:%u: size=%d, offset=%d, AOP_TYPE(res)=%d", __FILE__, __LINE__, size, offset,
+                    AOP_TYPE (result));
+
+      if (AOP_TYPE (right) == AOP_LIT)
+      {
+        unsigned int lit = pic14aopLiteral (AOP (IC_RIGHT (ic))->aopu.aop_lit, offset);
+        //fprintf (stderr, "%s:%u: lit %d 0x%x\n", __FUNCTION__,__LINE__, lit, lit);
+        if (lit & 0xff)
+        {
+          emitpcode (POC_MOVLW, popGetLit (lit & 0xff));
+          emitpcode (POC_MOVWF, popGet (AOP (result), offset));
+        }
+        else
+        {
+          emitpcode (POC_CLRF, popGet (AOP (result), offset));
+        }
+      }
+      else
+      {
+        //fprintf (stderr, "%s:%u: no lit\n", __FUNCTION__,__LINE__);
+        emitpcode (POC_MOVFW, popGet (AOP (right), offset));
+        emitpcode (POC_MOVWF, popGet (AOP (result), offset));
+      }
+      offset++;
+    }
+  }
+
+  freeAsmop (right, NULL, ic, TRUE);
+  freeAsmop (result, NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genNearPointerSet - pic14_emitcode for near pointer put         */
+/*-----------------------------------------------------------------*/
+static void
+genNearPointerSet (operand * right, operand * result, iCode * ic)
+{
+  asmop *aop = NULL;
+  sym_link *ptype = operandType (result);
+  sym_link *retype = getSpec (operandType (right));
+  sym_link *letype = getSpec (ptype);
+  int direct = 0;
+
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  aopOp (result, ic, FALSE);
+
+#if 1
+  /* if the result is rematerializable &
+     in data space & not a bit variable */
+  //if (AOP_TYPE(result) == AOP_IMMD &&
+  if (AOP_TYPE (result) == AOP_PCODE && PIC_IS_DATA_PTR (ptype) && !IS_BITVAR (retype) && !IS_BITVAR (letype))
+    {
+      genDataPointerSet (right, result, ic);
+      freeAsmop (result, NULL, ic, TRUE);
+      return;
+    }
+#endif
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  aopOp (right, ic, FALSE);
+  DEBUGpic14_AopType (__LINE__, NULL, right, result);
+
+  /* Check if can access directly instead of via a pointer */
+  if ((AOP_TYPE (result) == AOP_PCODE) && (AOP (result)->aopu.pcop->type == PO_IMMEDIATE) && (AOP_SIZE (right) == 1))
+    {
+      direct = 1;
+    }
+
+  if (IS_BITFIELD (letype))
+    {
+      genPackBits (letype, result, right, direct ? -1 : POINTER);
+      return;
+    }
+
+  /* If the pointer value is not in a the FSR then need to put it in */
+  /* Must set/reset IRP bit for use with FSR. */
+  /* Note only do this once - assuming that never need to cross a bank boundary at address 0x100. */
+  if (!direct)
+    setup_fsr (result);
+
+  {
+    /* we have can just get the values */
+    int size = AOP_SIZE (right);
+    int offset = 0;
+
+    DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+    while (size--)
+      {
+        char *l = aopGet (AOP (right), offset, FALSE, TRUE);
+        if (*l == '@')
+          {
+            emitpcode (POC_MOVFW, popCopyReg (pc_indf));
+          }
+        else
+          {
+            if (AOP_TYPE (right) == AOP_LIT)
+              {
+                emitpcode (POC_MOVLW, popGet (AOP (right), offset));
+              }
+            else
+              {
+                emitpcode (POC_MOVFW, popGet (AOP (right), offset));
+              }
+            if (direct)
+              emitpcode (POC_MOVWF, popGet (AOP (result), 0));
+            else
+              emitpcode (POC_MOVWF, popCopyReg (pc_indf));
+          }
+        if (size && !direct)
+          inc_fsr (1);
+        offset++;
+      }
+  }
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  /* now some housekeeping stuff */
+  if (aop)
+    {
+      /* we had to allocate for this iCode */
+      freeAsmop (NULL, aop, ic, TRUE);
+    }
+  else if (!direct)
+    {
+      /* nothing to do */
+    }
+  else
+    {
+      /* we did not allocate which means left
+         already in a pointer register, then
+         if size > 0 && this could be used again
+         we have to point it back to where it
+         belongs */
+      DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+      if (AOP_SIZE (right) > 1 && !OP_SYMBOL (result)->remat && (OP_SYMBOL (result)->liveTo > ic->seq || ic->depth))
+        {
+          int size = AOP_SIZE (right) - 1;
+          inc_fsr (-size);
+        }
+    }
+
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  /* done */
+
+  freeAsmop (right, NULL, ic, TRUE);
+  freeAsmop (result, NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genGenPointerSet - set value from generic pointer space         */
+/*-----------------------------------------------------------------*/
+static void
+genGenPointerSet (operand * right, operand * result, iCode * ic)
+{
+  sym_link *retype = getSpec (operandType (result));
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  aopOp (right, ic, FALSE);
+  aopOp (result, ic, FALSE);
+
+
+  DEBUGpic14_AopType (__LINE__, right, NULL, result);
+
+  if (IS_BITFIELD (retype))
+    {
+      genPackBits (retype, result, right, GPOINTER);
+      return;
+    }
+
+  {
+    /* emit call to __gptrput */
+    char *func[] = { NULL, "__gptrput1", "__gptrput2", "__gptrput3", "__gptrput4" };
+    int size = AOP_SIZE (right);
+    int idx = 0;
+
+    /* The following assertion fails for
+     *   struct foo { char a; char b; } bar;
+     *   void demo(struct foo *dst, char c) { dst->b = c; }
+     * as size will be 1 (sizeof(c)), whereas dst->b will be accessed
+     * using (((char *)dst)+1), whose OP_SYM_ETYPE still is struct foo
+     * of size 2.
+     * The frontend seems to guarantee that IC_LEFT has the correct size,
+     * it works fine both for larger and smaller types of `char c'.
+     * */
+    //assert (size == getSize(OP_SYM_ETYPE(result)));
+    assert (size > 0 && size <= 4);
+
+    /* pass arguments */
+    /* - value (MSB in Gstack_base_addr-2, growing downwards) */
+    {
+      int off = size;
+      idx = 2;
+      while (off--)
+        {
+          mov2w_op (right, off);
+          emitpcode (POC_MOVWF, popRegFromIdx (Gstack_base_addr - idx++));
+        }
+      idx = 0;
+    }
+    /* - address */
+    assert (AOP_SIZE (result) == 3);
+    mov2w (AOP (result), 0);
+    emitpcode (POC_MOVWF, popRegFromIdx (Gstack_base_addr - 1));
+    mov2w (AOP (result), 1);
+    emitpcode (POC_MOVWF, popRegFromIdx (Gstack_base_addr));
+    mov2w (AOP (result), 2);
+    call_libraryfunc (func[size]);
+  }
+
+  freeAsmop (right, NULL, ic, TRUE);
+  freeAsmop (result, NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genPointerSet - stores the value into a pointer location        */
+/*-----------------------------------------------------------------*/
+static void
+genPointerSet (iCode * ic)
+{
+  operand *right, *result;
+  sym_link *type, *etype;
+  int p_type;
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+  right = IC_RIGHT (ic);
+  result = IC_RESULT (ic);
+
+  /* depending on the type of pointer we need to
+     move it to the correct pointer register */
+  type = operandType (result);
+  etype = getSpec (type);
+  /* if left is of type of pointer then it is simple */
+  if (IS_PTR (type) && !IS_FUNC (type->next))
+    {
+      p_type = DCL_TYPE (type);
+    }
+  else
+    {
+      /* we have to go by the storage class */
+      p_type = PTR_TYPE (SPEC_OCLS (etype));
+
+      /*  if (SPEC_OCLS(etype)->codesp ) { */
+      /*      p_type = CPOINTER ;  */
+      /*  } */
+      /*  else */
+      /*      if (SPEC_OCLS(etype)->fmap && !SPEC_OCLS(etype)->paged) */
+      /*    p_type = FPOINTER ; */
+      /*      else */
+      /*    if (SPEC_OCLS(etype)->fmap && SPEC_OCLS(etype)->paged) */
+      /*        p_type = PPOINTER ; */
+      /*    else */
+      /*        if (SPEC_OCLS(etype) == idata ) */
+      /*      p_type = IPOINTER ; */
+      /*        else */
+      /*      p_type = POINTER ; */
+    }
+
+  /* now that we have the pointer type we assign
+     the pointer values */
+  switch (p_type)
+    {
+    case POINTER:
+    case FPOINTER:
+      //case IPOINTER:
+      genNearPointerSet (right, result, ic);
+      break;
+      /*
+         case PPOINTER:
+         genPagedPointerSet (right,result,ic);
+         break;
+
+         case FPOINTER:
+         genFarPointerSet (right,result,ic);
+         break;
+       */
+    case GPOINTER:
+      genGenPointerSet (right, result, ic);
+      break;
+
+    default:
+      werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "genPointerSet: illegal pointer type");
+    }
+}
+
+/*-----------------------------------------------------------------*/
+/* genIfx - generate code for Ifx statement                        */
+/*-----------------------------------------------------------------*/
+static void
+genIfx (iCode * ic, iCode * popIc)
+{
+  operand *cond = IC_COND (ic);
+  int isbit = 0;
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+  aopOp (cond, ic, FALSE);
+
+  /* get the value into acc */
+  if (AOP_TYPE (cond) != AOP_CRY)
+    pic14_toBoolean (cond);
+  else
+    isbit = 1;
+
+  /* if there was something to be popped then do it */
+  if (popIc)
+    genIpop (popIc);
+
+  if (isbit)
+    {
+      /* This assumes that CARRY is set iff cond is true */
+      if (IC_TRUE (ic))
+        {
+          assert (!IC_FALSE (ic));
+          emitpcode (POC_BTFSC, popGet (AOP (cond), 0));
+          //emitSKPNC;
+          emitpcode (POC_GOTO, popGetLabel (IC_TRUE (ic)->key));
+        }
+      else
+        {
+          assert (IC_FALSE (ic));
+          emitpcode (POC_BTFSS, popGet (AOP (cond), 0));
+          //emitSKPC;
+          emitpcode (POC_GOTO, popGetLabel (IC_FALSE (ic)->key));
+        }
+      if (0)
+        {
+          static int hasWarned = 0;
+          if (!hasWarned)
+            {
+              fprintf (stderr, "WARNING: using untested code for %s:%u -- please check the .asm output and report bugs.\n",
+                       ic->filename, ic->lineno);
+              hasWarned = 1;
+            }
+        }
+    }
+  else
+    {
+      /* now Z is set iff !cond */
+      if (IC_TRUE (ic))
+        {
+          assert (!IC_FALSE (ic));
+          emitSKPZ;
+          emitpcode (POC_GOTO, popGetLabel (IC_TRUE (ic)->key));
+        }
+      else
+        {
+          emitSKPNZ;
+          emitpcode (POC_GOTO, popGetLabel (IC_FALSE (ic)->key));
+        }
+    }
+
+  ic->generated = TRUE;
+
+  /* the result is now in the accumulator */
+  freeAsmop (cond, NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genAddrOf - generates code for address of                       */
+/*-----------------------------------------------------------------*/
+static void
+genAddrOf (iCode * ic)
+{
+  operand *right, *result, *left;
+  int size, offset;
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+
+  //aopOp(IC_RESULT(ic),ic,FALSE);
+
+  aopOp ((left = IC_LEFT (ic)), ic, FALSE);
+  aopOp ((right = IC_RIGHT (ic)), ic, FALSE);
+  aopOp ((result = IC_RESULT (ic)), ic, TRUE);
+
+  DEBUGpic14_AopType (__LINE__, left, right, result);
+  assert (IS_SYMOP (left));
+
+  /* sanity check: generic pointers to code space are not yet supported,
+   * pionters to codespace must not be assigned addresses of __data values. */
+#if 0
+  fprintf (stderr, "result: %s, left: %s\n", OP_SYMBOL (result)->name, OP_SYMBOL (left)->name);
+  fprintf (stderr, "result->type : ");
+  printTypeChain (OP_SYM_TYPE (result), stderr);
+  fprintf (stderr, ", codesp:%d, codeptr:%d, constptr:%d\n", IN_CODESPACE (SPEC_OCLS (getSpec (OP_SYM_TYPE (result)))),
+           IS_CODEPTR (OP_SYM_TYPE (result)), IS_PTR_CONST (OP_SYM_TYPE (result)));
+  fprintf (stderr, "result->etype: ");
+  printTypeChain (OP_SYM_ETYPE (result), stderr);
+  fprintf (stderr, ", codesp:%d, codeptr:%d, constptr:%d\n", IN_CODESPACE (SPEC_OCLS (getSpec (OP_SYM_ETYPE (result)))),
+           IS_CODEPTR (OP_SYM_ETYPE (result)), IS_PTR_CONST (OP_SYM_ETYPE (result)));
+  fprintf (stderr, "left->type   : ");
+  printTypeChain (OP_SYM_TYPE (left), stderr);
+  fprintf (stderr, ", codesp:%d, codeptr:%d, constptr:%d\n", IN_CODESPACE (SPEC_OCLS (getSpec (OP_SYM_TYPE (left)))),
+           IS_CODEPTR (OP_SYM_TYPE (left)), IS_PTR_CONST (OP_SYM_TYPE (left)));
+  fprintf (stderr, "left->etype  : ");
+  printTypeChain (OP_SYM_ETYPE (left), stderr);
+  fprintf (stderr, ", codesp:%d, codeptr:%d, constptr:%d\n", IN_CODESPACE (SPEC_OCLS (getSpec (OP_SYM_ETYPE (left)))),
+           IS_CODEPTR (OP_SYM_ETYPE (left)), IS_PTR_CONST (OP_SYM_ETYPE (left)));
+#endif
+
+  if (IS_SYMOP (result) && IS_CODEPTR (OP_SYM_TYPE (result)) && !IN_CODESPACE (SPEC_OCLS (getSpec (OP_SYM_TYPE (left)))))
+    {
+      fprintf (stderr, "trying to assign __code pointer (%s) an address in __data space (&%s) -- expect trouble\n",
+               IS_SYMOP (result) ? OP_SYMBOL (result)->name : "unknown", OP_SYMBOL (left)->name);
+    }
+  else if (IS_SYMOP (result) && !IS_CODEPTR (OP_SYM_TYPE (result)) && IN_CODESPACE (SPEC_OCLS (getSpec (OP_SYM_TYPE (left)))))
+    {
+      fprintf (stderr, "trying to assign __data pointer (%s) an address in __code space (&%s) -- expect trouble\n",
+               IS_SYMOP (result) ? OP_SYMBOL (result)->name : "unknown", OP_SYMBOL (left)->name);
+    }
+
+  size = AOP_SIZE (IC_RESULT (ic));
+  if (IS_SYMOP (result) && IS_GENPTR (OP_SYM_TYPE (result)))
+    {
+      /* strip tag */
+      if (size > GPTRSIZE - 1)
+        size = GPTRSIZE - 1;
+    }
+  offset = 0;
+
+  while (size--)
+    {
+      /* fixing bug #863624, reported from (errolv) */
+      emitpcode (POC_MOVLW, popGetImmd (OP_SYMBOL (left)->rname, offset, 0, IS_FUNC (OP_SYM_TYPE (left))));
+      emitpcode (POC_MOVWF, popGet (AOP (result), offset));
+
+#if 0
+      emitpcode (POC_MOVLW, popGet (AOP (left), offset));
+      emitpcode (POC_MOVWF, popGet (AOP (result), offset));
+#endif
+      offset++;
+    }
+
+  if (IS_SYMOP (result) && IS_GENPTR (OP_SYM_TYPE (result)))
+    {
+      /* provide correct tag */
+      int isCode = IN_CODESPACE (SPEC_OCLS (getSpec (OP_SYM_TYPE (left))));
+      emitpcode (POC_MOVLW, popGetLit (isCode ? GPTRTAG_CODE : GPTRTAG_DATA));
+      movwf (AOP (result), 2);
+    }
+
+  freeAsmop (left, NULL, ic, FALSE);
+  freeAsmop (result, NULL, ic, TRUE);
+
+}
+
+/*-----------------------------------------------------------------*/
+/* genAssign - generate code for assignment                        */
+/*-----------------------------------------------------------------*/
+static void
+genAssign (iCode * ic)
+{
+  operand *result, *right;
+  int size, offset, know_W;
+  unsigned long lit = 0L;
+
+  result = IC_RESULT (ic);
+  right = IC_RIGHT (ic);
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+  /* if they are the same */
+  if (operandsEqu (IC_RESULT (ic), IC_RIGHT (ic)))
+    return;
+
+  aopOp (right, ic, FALSE);
+  aopOp (result, ic, TRUE);
+
+  DEBUGpic14_AopType (__LINE__, NULL, right, result);
+
+  /* if they are the same registers */
+  if (pic14_sameRegs (AOP (right), AOP (result)))
+    goto release;
+
+  /* special case: assign from __code */
+  if (!IS_ITEMP (right)         /* --> iTemps never reside in __code */
+      && IS_SYMOP (right)       /* --> must be an immediate (otherwise we would be in genConstPointerGet) */
+      && !IS_FUNC (OP_SYM_TYPE (right)) /* --> we would want its address instead of the first instruction */
+      && !IS_CODEPTR (OP_SYM_TYPE (right))      /* --> get symbols address instread */
+      && IN_CODESPACE (SPEC_OCLS (getSpec (OP_SYM_TYPE (right)))))
+    {
+      emitpComment ("genAssign from CODESPACE");
+      genConstPointerGet (right, result, ic);
+      goto release;
+    }
+
+  /* just for symmetry reasons... */
+  if (!IS_ITEMP (result) && IS_SYMOP (result) && IN_CODESPACE (SPEC_OCLS (getSpec (OP_SYM_TYPE (result)))))
+    {
+      assert (!"cannot write to CODESPACE");
+    }
+
+  /* if the result is a bit */
+  if (AOP_TYPE (result) == AOP_CRY)
+    {
+
+      /* if the right size is a literal then
+         we know what the value is */
+      if (AOP_TYPE (right) == AOP_LIT)
+        {
+
+          emitpcode ((((int) operandLitValue (right)) ? POC_BSF : POC_BCF), popGet (AOP (result), 0));
+
+          if (((int) operandLitValue (right)))
+            pic14_emitcode ("bsf", "(%s >> 3),(%s & 7)", AOP (result)->aopu.aop_dir, AOP (result)->aopu.aop_dir);
+          else
+            pic14_emitcode ("bcf", "(%s >> 3),(%s & 7)", AOP (result)->aopu.aop_dir, AOP (result)->aopu.aop_dir);
+          goto release;
+        }
+
+      /* the right is also a bit variable */
+      if (AOP_TYPE (right) == AOP_CRY)
+        {
+          emitpcode (POC_BCF, popGet (AOP (result), 0));
+          emitpcode (POC_BTFSC, popGet (AOP (right), 0));
+          emitpcode (POC_BSF, popGet (AOP (result), 0));
+
+          pic14_emitcode ("bcf", "(%s >> 3),(%s & 7)", AOP (result)->aopu.aop_dir, AOP (result)->aopu.aop_dir);
+          pic14_emitcode ("btfsc", "(%s >> 3),(%s & 7)", AOP (right)->aopu.aop_dir, AOP (right)->aopu.aop_dir);
+          pic14_emitcode ("bsf", "(%s >> 3),(%s & 7)", AOP (result)->aopu.aop_dir, AOP (result)->aopu.aop_dir);
+          goto release;
+        }
+
+      /* we need to or */
+      emitpcode (POC_BCF, popGet (AOP (result), 0));
+      pic14_toBoolean (right);
+      emitSKPZ;
+      emitpcode (POC_BSF, popGet (AOP (result), 0));
+      //aopPut(AOP(result),"a",0);
+      goto release;
+    }
+
+  /* bit variables done */
+  /* general case */
+  size = AOP_SIZE (result);
+  offset = 0;
+  if (AOP_TYPE (right) == AOP_DIR && (AOP_TYPE (result) == AOP_REG) && size == 1)
+    {
+      DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+      if (aopIdx (AOP (result), 0) == 4)
+        {
+          DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+          emitpcode (POC_MOVFW, popGet (AOP (right), offset));
+          emitpcode (POC_MOVWF, popGet (AOP (result), offset));
+          goto release;
+        }
+      else
+        DEBUGpic14_emitcode ("; WARNING", "%s  %d ignoring register storage", __FUNCTION__, __LINE__);
+    }
+
+  know_W = -1;
+  while (size--)
+    {
+
+      DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+      if (AOP_TYPE (right) == AOP_LIT)
+        {
+          lit = (unsigned long) pic14aopLiteral (AOP (right)->aopu.aop_lit, offset) & 0x0ff;
+          if (lit & 0xff)
+            {
+              if (know_W != (int) (lit & 0xff))
+                emitpcode (POC_MOVLW, popGetLit (lit & 0xff));
+              know_W = lit & 0xff;
+              emitpcode (POC_MOVWF, popGet (AOP (result), offset));
+            }
+          else
+            emitpcode (POC_CLRF, popGet (AOP (result), offset));
+
+        }
+      else if (AOP_TYPE (right) == AOP_CRY)
+        {
+          emitpcode (POC_CLRF, popGet (AOP (result), offset));
+          if (offset == 0)
+            {
+              emitpcode (POC_BTFSS, popGet (AOP (right), 0));
+              emitpcode (POC_INCF, popGet (AOP (result), 0));
+            }
+        }
+      else
+        {
+          mov2w_op (right, offset);
+          emitpcode (POC_MOVWF, popGet (AOP (result), offset));
+        }
+
+      offset++;
+    }
+
+
+release:
+  freeAsmop (right, NULL, ic, FALSE);
+  freeAsmop (result, NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genJumpTab - generates code for jump table                      */
+/*-----------------------------------------------------------------*/
+static void
+genJumpTab (iCode * ic)
+{
+  symbol *jtab;
+  char *l;
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+  aopOp (IC_JTCOND (ic), ic, FALSE);
+  /* get the condition into accumulator */
+  l = aopGet (AOP (IC_JTCOND (ic)), 0, FALSE, FALSE);
+  MOVA (l);
+  /* multiply by three */
+  pic14_emitcode ("add", "a,acc");
+  pic14_emitcode ("add", "a,%s", aopGet (AOP (IC_JTCOND (ic)), 0, FALSE, FALSE));
+
+  jtab = newiTempLabel (NULL);
+  pic14_emitcode ("mov", "dptr,#%05d_DS_", labelKey2num (jtab->key));
+  pic14_emitcode ("jmp", "@a+dptr");
+  pic14_emitcode ("", "%05d_DS_:", labelKey2num (jtab->key));
+
+  emitpcode (POC_MOVLW, popGetHighLabel (jtab->key));
+  emitpcode (POC_MOVWF, popCopyReg (&pc_pclath));
+  emitpcode (POC_MOVLW, popGetLabel (jtab->key));
+  emitpcode (POC_ADDFW, popGet (AOP (IC_JTCOND (ic)), 0));
+  emitSKPNC;
+  emitpcode (POC_INCF, popCopyReg (&pc_pclath));
+  emitpcode (POC_MOVWF, popCopyReg (&pc_pcl));
+  emitpLabel (jtab->key);
+
+  freeAsmop (IC_JTCOND (ic), NULL, ic, TRUE);
+
+  /* now generate the jump labels */
+  for (jtab = setFirstItem (IC_JTLABELS (ic)); jtab; jtab = setNextItem (IC_JTLABELS (ic)))
+    {
+      pic14_emitcode ("ljmp", "%05d_DS_", labelKey2num (jtab->key));
+      emitpcode (POC_GOTO, popGetLabel (jtab->key));
+
+    }
+
+}
+
+/*-----------------------------------------------------------------*/
+/* genCast - gen code for casting                                  */
+/*-----------------------------------------------------------------*/
+static void
+genCast (iCode * ic)
+{
+  operand *result = IC_RESULT (ic);
+  sym_link *restype = operandType (result);
+  sym_link *rtype = operandType (IC_RIGHT (ic));
+  operand *right = IC_RIGHT (ic);
+  int size, offset;
+
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  /* if they are equivalent then do nothing */
+  if (operandsEqu (IC_RESULT (ic), IC_RIGHT (ic)))
+    return;
+
+  aopOp (right, ic, FALSE);
+  aopOp (result, ic, FALSE);
+
+  DEBUGpic14_AopType (__LINE__, NULL, right, result);
+
+  /* if the result is a bit */
+  if (AOP_TYPE (result) == AOP_CRY)
+    {
+      assert (!"assigning to bit variables is not supported");
+    }
+
+  if ((AOP_TYPE (right) == AOP_CRY) && (AOP_TYPE (result) == AOP_REG))
+    {
+      int offset = 1;
+      size = AOP_SIZE (result);
+
+      DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+      emitpcode (POC_CLRF, popGet (AOP (result), 0));
+      emitpcode (POC_BTFSC, popGet (AOP (right), 0));
+      emitpcode (POC_INCF, popGet (AOP (result), 0));
+
+      while (size--)
+        emitpcode (POC_CLRF, popGet (AOP (result), offset++));
+
+      goto release;
+    }
+
+  if (IS_BOOL (operandType (result)))
+    {
+      pic14_toBoolean (right);
+      emitSKPNZ;
+      emitpcode (POC_MOVLW, popGetLit (1));
+      emitpcode (POC_MOVWF, popGet (AOP (result), 0));
+      goto release;
+    }
+
+  if (IS_PTR (restype))
+    {
+      operand *result = IC_RESULT (ic);
+      //operand *left = IC_LEFT(ic);
+      operand *right = IC_RIGHT (ic);
+      int tag = 0xff;
+
+      /* copy common part */
+      int max, size = AOP_SIZE (result);
+      if (size > AOP_SIZE (right))
+        size = AOP_SIZE (right);
+      DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+      /* warn if we discard generic opinter tag */
+      if (!IS_GENPTR (restype) && IS_GENPTR (rtype) && (AOP_SIZE (result) < AOP_SIZE (right)))
+        {
+          //fprintf (stderr, "%s:%u: discarding generic pointer type tag\n", __FUNCTION__, __LINE__);
+        }                       // if
+
+      max = size;
+      while (size--)
+        {
+          mov2w_op (right, size);
+          movwf (AOP (result), size);
+        }                       // while
+
+      /* upcast into generic pointer type? */
+      if (IS_GENPTR (restype) && (size < AOP_SIZE (result)) && (!IS_GENPTR (rtype) || AOP_SIZE (right) < GPTRSIZE))
+        {
+          //fprintf (stderr, "%s:%u: must determine pointer type\n", __FUNCTION__, __LINE__);
+          if (IS_PTR (rtype))
+            {
+              switch (DCL_TYPE (rtype))
+                {
+                case POINTER:  /* __data */
+                case FPOINTER: /* __data */
+                  assert (AOP_SIZE (right) == 2);
+                  tag = GPTRTAG_DATA;
+                  break;
+
+                case CPOINTER: /* __code */
+                  assert (AOP_SIZE (right) == 2);
+                  tag = GPTRTAG_CODE;
+                  break;
+
+                case GPOINTER: /* unknown destination, __data or __code */
+                  /* assume __data space (address of immediate) */
+                  assert (AOP_TYPE (right) == AOP_PCODE && AOP (right)->aopu.pcop->type == PO_IMMEDIATE);
+                  if (AOP (right)->code)
+                    tag = GPTRTAG_CODE;
+                  else
+                    tag = GPTRTAG_DATA;
+                  break;
+
+                default:
+                  assert (!"unhandled pointer type");
+                }               // switch
+            }
+          else
+            {
+              /* convert other values into pointers to __data space */
+              tag = GPTRTAG_DATA;
+            }
+
+          assert (AOP_SIZE (result) == 3);
+          if (tag == 0)
+            {
+              emitpcode (POC_CLRF, popGet (AOP (result), 2));
+            }
+          else
+            {
+              emitpcode (POC_MOVLW, popGetLit (tag));
+              movwf (AOP (result), 2);
+            }
+        }
+      else
+        {
+          addSign (result, max, 0);
+        }                       // if
+      goto release;
+    }
+
+  /* if they are the same size : or less */
+  if (AOP_SIZE (result) <= AOP_SIZE (right))
+    {
+
+      /* if they are in the same place */
+      if (pic14_sameRegs (AOP (right), AOP (result)))
+        goto release;
+
+      DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+      if (IS_PTR_CONST (rtype))
+        DEBUGpic14_emitcode ("; ***", "%d - right is const pointer", __LINE__);
+      if (IS_PTR_CONST (operandType (IC_RESULT (ic))))
+        DEBUGpic14_emitcode ("; ***", "%d - result is const pointer", __LINE__);
+
+      if ((AOP_TYPE (right) == AOP_PCODE) && AOP (right)->aopu.pcop->type == PO_IMMEDIATE)
+        {
+          emitpcode (POC_MOVLW, popGetAddr (AOP (right), 0, 0));
+          emitpcode (POC_MOVWF, popGet (AOP (result), 0));
+          emitpcode (POC_MOVLW, popGetAddr (AOP (right), 1, 0));
+          emitpcode (POC_MOVWF, popGet (AOP (result), 1));
+          if (AOP_SIZE (result) < 2)
+            fprintf (stderr, "%d -- result is not big enough to hold a ptr\n", __LINE__);
+
+        }
+      else
+        {
+
+          /* if they in different places then copy */
+          size = AOP_SIZE (result);
+          offset = 0;
+          while (size--)
+            {
+              emitpcode (POC_MOVFW, popGet (AOP (right), offset));
+              emitpcode (POC_MOVWF, popGet (AOP (result), offset));
+
+              //aopPut(AOP(result),
+              // aopGet(AOP(right),offset,FALSE,FALSE),
+              // offset);
+
+              offset++;
+            }
+        }
+      goto release;
+    }
+
+  /* so we now know that the size of destination is greater
+     than the size of the source. */
+
+  /* we move to result for the size of source */
+  size = AOP_SIZE (right);
+  offset = 0;
+  while (size--)
+    {
+      emitpcode (POC_MOVFW, popGet (AOP (right), offset));
+      emitpcode (POC_MOVWF, popGet (AOP (result), offset));
+      offset++;
+    }
+
+  addSign (result, AOP_SIZE (right), !SPEC_USIGN (rtype));
+
+release:
+  freeAsmop (right, NULL, ic, TRUE);
+  freeAsmop (result, NULL, ic, TRUE);
+
+}
+
+/*-----------------------------------------------------------------*/
+/* genDjnz - generate decrement & jump if not zero instrucion      */
+/*-----------------------------------------------------------------*/
+static int
+genDjnz (iCode * ic, iCode * ifx)
+{
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+  if (!ifx)
+    return 0;
+
+  /* if the if condition has a false label
+     then we cannot save */
+  if (IC_FALSE (ifx))
+    return 0;
+
+  /* if the minus is not of the form
+     a = a - 1 */
+  if (!isOperandEqual (IC_RESULT (ic), IC_LEFT (ic)) || !IS_OP_LITERAL (IC_RIGHT (ic)))
+    return 0;
+
+  if (operandLitValue (IC_RIGHT (ic)) != 1)
+    return 0;
+
+  /* if the size of this greater than one then no
+     saving */
+  if (getSize (operandType (IC_RESULT (ic))) > 1)
+    return 0;
+
+  /* otherwise we can save BIG */
+  aopOp (IC_RESULT (ic), ic, FALSE);
+
+  emitpcode (POC_DECFSZ, popGet (AOP (IC_RESULT (ic)), 0));
+  emitpcode (POC_GOTO, popGetLabel (IC_TRUE (ifx)->key));
+
+  freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+  ifx->generated = TRUE;
+  return 1;
+}
+
+/*-----------------------------------------------------------------*/
+/* genReceive - generate code for a receive iCode                  */
+/*-----------------------------------------------------------------*/
+static void
+genReceive (iCode * ic)
+{
+  FENTRY;
+  DEBUGpic14_emitcode ("; ***", "%s  %d", __FUNCTION__, __LINE__);
+
+  if (isOperandInFarSpace (IC_RESULT (ic)) && (OP_SYMBOL (IC_RESULT (ic))->isspilt || IS_TRUE_SYMOP (IC_RESULT (ic))))
+    {
+
+      int size = getSize (operandType (IC_RESULT (ic)));
+      int offset = fReturnSizePic - size;
+      while (size--)
+        {
+          pic14_emitcode ("push", "%s", (strcmp (fReturn[fReturnSizePic - offset - 1], "a") ?
+                                         fReturn[fReturnSizePic - offset - 1] : "acc"));
+          offset++;
+        }
+      aopOp (IC_RESULT (ic), ic, FALSE);
+      size = AOP_SIZE (IC_RESULT (ic));
+      offset = 0;
+      while (size--)
+        {
+          pic14_emitcode ("pop", "acc");
+          aopPut (AOP (IC_RESULT (ic)), "a", offset++);
+        }
+
+    }
+  else
+    {
+      _G.accInUse++;
+      aopOp (IC_RESULT (ic), ic, FALSE);
+      _G.accInUse--;
+      GpseudoStkPtr = ic->parmBytes;    // address used arg on stack
+      assignResultValue (IC_RESULT (ic));
+    }
+
+  freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genDummyRead - generate code for dummy read of volatiles        */
+/*-----------------------------------------------------------------*/
+static void
+genDummyRead (iCode * ic)
+{
+  FENTRY;
+  pic14_emitcode ("; genDummyRead", "");
+  pic14_emitcode ("; not implemented", "");
+
+  ic = ic;
+}
+
+/*-----------------------------------------------------------------*/
+/* genpic14Code - generate code for pic14 based controllers        */
+/*-----------------------------------------------------------------*/
+/*
+* At this point, ralloc.c has gone through the iCode and attempted
+* to optimize in a way suitable for a PIC. Now we've got to generate
+* PIC instructions that correspond to the iCode.
+*
+* Once the instructions are generated, we'll pass through both the
+* peep hole optimizer and the pCode optimizer.
+*-----------------------------------------------------------------*/
+
+void
+genpic14Code (iCode * lic)
+{
+  iCode *ic;
+  int cln = 0;
+  const char *cline;
+
+  FENTRY;
+
+  pic = pic14_getPIC();
+
+  pb = newpCodeChain (GcurMemmap, 0, newpCodeCharP ("; Starting pCode block"));
+  addpBlock (pb);
+
+  /* if debug information required */
+  if (options.debug && debugFile && currFunc)
+    {
+      debugFile->writeFunction (currFunc, lic);
+    }
+
+
+  for (ic = lic; ic; ic = ic->next)
+    {
+      initGenLineElement ();
+
+      //DEBUGpic14_emitcode(";ic","");
+      //fprintf (stderr, "in ic loop\n");
+      //pic14_emitcode ("", ";\t%s:%d: %s", ic->filename,
+      //ic->lineno, printCLine(ic->filename, ic->lineno));
+
+      if (!options.noCcodeInAsm && (cln != ic->lineno))
+        {
+          cln = ic->lineno;
+          //fprintf (stderr, "%s\n", printCLine (ic->filename, ic->lineno));
+          cline = printCLine (ic->filename, ic->lineno);
+          if (!cline || strlen (cline) == 0)
+            cline = printCLine (ic->filename, ic->lineno);
+          addpCode2pBlock (pb, newpCodeCSource (ic->lineno, ic->filename, cline));
+          //emitpComment ("[C-SRC] %s:%d: %s", ic->filename, cln, cline);
+        }
+
+      if (options.iCodeInAsm)
+        {
+          const char *iLine = printILine (ic);
+          emitpComment ("[ICODE] %s:%d: %s", ic->filename, ic->lineno, printILine (ic));
+          dbuf_free (iLine);
+        }
+      /* if the result is marked as
+         spilt and rematerializable or code for
+         this has already been generated then
+         do nothing */
+      if (resultRemat (ic) || ic->generated)
+        continue;
+
+      /* depending on the operation */
+      switch (ic->op)
+        {
+        case '!':
+          genNot (ic);
+          break;
+
+        case '~':
+          genCpl (ic);
+          break;
+
+        case UNARYMINUS:
+          genUminus (ic);
+          break;
+
+        case IPUSH:
+          genIpush (ic);
+          break;
+
+        case IPOP:
+          /* IPOP happens only when trying to restore a
+             spilt live range, if there is an ifx statement
+             following this pop then the if statement might
+             be using some of the registers being popped which
+             would destory the contents of the register so
+             we need to check for this condition and handle it */
+          if (ic->next && ic->next->op == IFX && regsInCommon (IC_LEFT (ic), IC_COND (ic->next)))
+            genIfx (ic->next, ic);
+          else
+            genIpop (ic);
+          break;
+
+        case CALL:
+          genCall (ic);
+          break;
+
+        case PCALL:
+          genPcall (ic);
+          break;
+
+        case FUNCTION:
+          genFunction (ic);
+          break;
+
+        case ENDFUNCTION:
+          genEndFunction (ic);
+          break;
+
+        case RETURN:
+          genRet (ic);
+          break;
+
+        case LABEL:
+          genLabel (ic);
+          break;
+
+        case GOTO:
+          genGoto (ic);
+          break;
+
+        case '+':
+          genPlus (ic);
+          break;
+
+        case '-':
+          if (!genDjnz (ic, ifxForOp (IC_RESULT (ic), ic)))
+            genMinus (ic);
+          break;
+
+        case '*':
+          genMult (ic);
+          break;
+
+        case '/':
+          genDiv (ic);
+          break;
+
+        case '%':
+          genMod (ic);
+          break;
+
+        case '>':
+          genCmpGt (ic, ifxForOp (IC_RESULT (ic), ic));
+          break;
+
+        case '<':
+          genCmpLt (ic, ifxForOp (IC_RESULT (ic), ic));
+          break;
+
+        case LE_OP:
+        case GE_OP:
+        case NE_OP:
+
+          /* note these two are xlated by algebraic equivalence
+             during parsing SDCC.y */
+          werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "got '>=' or '<=' shouldn't have come here");
+          break;
+
+        case EQ_OP:
+          genCmpEq (ic, ifxForOp (IC_RESULT (ic), ic));
+          break;
+
+        case AND_OP:
+          genAndOp (ic);
+          break;
+
+        case OR_OP:
+          genOrOp (ic);
+          break;
+
+        case '^':
+          genXor (ic, ifxForOp (IC_RESULT (ic), ic));
+          break;
+
+        case '|':
+          genOr (ic, ifxForOp (IC_RESULT (ic), ic));
+          break;
+
+        case BITWISEAND:
+          genAnd (ic, ifxForOp (IC_RESULT (ic), ic));
+          break;
+
+        case INLINEASM:
+          pic14_genInline (ic);
+          break;
+
+        case RRC:
+          genRRC (ic);
+          break;
+
+        case RLC:
+          genRLC (ic);
+          break;
+
+        case GETABIT:
+          genGetABit (ic);
+          break;
+
+        case GETHBIT:
+          genGetHbit (ic);
+          break;
+
+        case LEFT_OP:
+          genLeftShift (ic);
+          break;
+
+        case RIGHT_OP:
+          genRightShift (ic);
+          break;
+
+        case GET_VALUE_AT_ADDRESS:
+          genPointerGet (ic);
+          break;
+
+        case '=':
+          if (POINTER_SET (ic))
+            genPointerSet (ic);
+          else
+            genAssign (ic);
+          break;
+
+        case IFX:
+          genIfx (ic, NULL);
+          break;
+
+        case ADDRESS_OF:
+          genAddrOf (ic);
+          break;
+
+        case JUMPTABLE:
+          genJumpTab (ic);
+          break;
+
+        case CAST:
+          genCast (ic);
+          break;
+
+        case RECEIVE:
+          genReceive (ic);
+          break;
+
+        case SEND:
+          addSet (&_G.sendSet, ic);
+          break;
+
+        case DUMMY_READ_VOLATILE:
+          genDummyRead (ic);
+          break;
+
+        case CRITICAL:
+          genCritical (ic);
+          break;
+
+        case ENDCRITICAL:
+          genEndCritical (ic);
+          break;
+
+        default:
+          fprintf (stderr, "UNHANDLED iCode: ");
+          piCode (ic, stderr);
+          ic = ic;
+          break;
+        }
+    }
+
+
+  /* now we are ready to call the
+     peep hole optimizer */
+  if (!options.nopeep)
+    {
+      peepHole (&genLine.lineHead);
+    }
+  /* now do the actual printing */
+  printLine (genLine.lineHead, codeOutBuf);
+
+#ifdef PCODE_DEBUG
+  DFPRINTF ((stderr, "printing pBlock\n\n"));
+  printpBlock (stdout, pb);
+#endif
+
+  /* destroy the line list */
+  destroy_line_list ();
+}
+
+/* This is not safe, as a AOP_PCODE/PO_IMMEDIATE might be used both as literal
+ * (meaning: representing its own address) or not (referencing its contents).
+ * This can only be decided based on the operand's type. */
+static int
+aop_isLitLike (asmop * aop)
+{
+  assert (aop);
+  if (aop->type == AOP_LIT)
+    return TRUE;
+  if (aop->type == AOP_IMMD)
+    return TRUE;
+  if ((aop->type == AOP_PCODE) &&
+      ((aop->aopu.pcop->type == PO_LITERAL) ||
+       (aop->aopu.pcop->type == PO_IMMEDIATE)))
+    {
+      /* this should be treated like a literal/immediate (use MOVLW/ADDLW/SUBLW
+       * instead of MOVFW/ADDFW/SUBFW, use popGetAddr instead of popGet) */
+      return TRUE;
+    }
+  return FALSE;
+}
+
+int
+op_isLitLike (operand * op)
+{
+  assert (op);
+  if (aop_isLitLike (AOP (op)))
+    return TRUE;
+  if (IS_SYMOP (op) && IS_FUNC (OP_SYM_TYPE (op)))
+    return TRUE;
+  if (IS_SYMOP (op) && IS_PTR (OP_SYM_TYPE (op)) && (AOP_TYPE (op) == AOP_PCODE) && (AOP (op)->aopu.pcop->type == PO_IMMEDIATE))
+    {
+      return TRUE;
+    }
+
+  return FALSE;
+}