X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2FSDCCcse.c;h=1466760c72dc7b058d4fc612e4cbeb1008649b9e;hb=aaa16aad6fcd7bfcfd2c2070bcfe59bf0da07244;hp=ea64e30c70d5ce77e09ed2c851273144d20826c3;hpb=d78670def0d8de75614601941b3e69ce937b2714;p=fw%2Fsdcc

diff --git a/src/SDCCcse.c b/src/SDCCcse.c
index ea64e30c..1466760c 100644
--- a/src/SDCCcse.c
+++ b/src/SDCCcse.c
@@ -25,6 +25,7 @@
 #include "common.h"
 #include "newalloc.h"
 
+
 /*-----------------------------------------------------------------*/
 /* newCseDef - new cseDef                                          */
 /*-----------------------------------------------------------------*/
@@ -39,10 +40,65 @@ newCseDef (operand * sym, iCode * ic)
   cdp->sym = sym;
   cdp->diCode = ic;
   cdp->key = sym->key;
+  cdp->ancestors = newBitVect(iCodeKey);
+  cdp->fromGlobal = 0;
 
+  if (ic->op!=IF && ic->op!=JUMPTABLE)
+    {
+      if (IC_LEFT (ic) && IS_SYMOP (IC_LEFT (ic)))
+        {
+          bitVectSetBit (cdp->ancestors, IC_LEFT (ic)->key);
+          cdp->fromGlobal |= isOperandGlobal (IC_LEFT (ic));
+        }
+      if (IC_RIGHT (ic) && IS_SYMOP (IC_RIGHT (ic)))
+        {
+          bitVectSetBit (cdp->ancestors, IC_RIGHT (ic)->key);
+          cdp->fromGlobal |= isOperandGlobal (IC_RIGHT (ic));
+        }
+    }
+  
   return cdp;
 }
 
+void
+updateCseDefAncestors(cseDef *cdp, set * cseSet)
+{
+  cseDef *loop;
+  set *sl;
+  iCode *ic = cdp->diCode;
+  
+  if (ic->op!=IF && ic->op!=JUMPTABLE)
+    {
+      if (IC_LEFT (ic) && IS_SYMOP (IC_LEFT (ic)))
+        {
+          bitVectSetBit (cdp->ancestors, IC_LEFT (ic)->key);
+          for (sl = cseSet; sl; sl = sl->next)
+            {
+              loop = sl->item;
+              if (loop->sym->key == IC_LEFT (ic)->key)
+                {
+                  cdp->ancestors = bitVectUnion (cdp->ancestors, loop->ancestors);
+                  cdp->fromGlobal |= loop->fromGlobal;
+                  break;
+                }
+            }
+        }
+      if (IC_RIGHT (ic) && IS_SYMOP (IC_RIGHT (ic)))
+        {
+          bitVectSetBit (cdp->ancestors, IC_RIGHT (ic)->key);
+          for (sl = cseSet; sl; sl = sl->next)
+            {
+              loop = sl->item;
+              if (loop->sym->key == IC_RIGHT (ic)->key)
+                {
+                  cdp->ancestors = bitVectUnion (cdp->ancestors, loop->ancestors);
+                  cdp->fromGlobal |= loop->fromGlobal;
+                  break;
+                }
+            }
+        }
+    }
+}
 
 
 /*-----------------------------------------------------------------*/
@@ -83,9 +139,9 @@ pcseDef (void *item, va_list ap)
 
 void ReplaceOpWithCheaperOp(operand **op, operand *cop) {
 #ifdef RANGEHUNT
-  printf ("ReplaceOpWithCheaperOp (%s:%d with %s:%d): ", 
-	  OP_SYMBOL((*op))->name, OP_SYMBOL((*op))->isreqv,
-	  OP_SYMBOL(cop)->name, OP_SYMBOL(cop)->isreqv);
+  printf ("ReplaceOpWithCheaperOp %s with %s: ",
+	  IS_SYMOP((*op)) ? OP_SYMBOL((*op))->name : "!SYM",
+	  IS_SYMOP(cop) ? OP_SYMBOL(cop)->name : "!SYM");
   // if op is a register equivalent
   if (IS_ITEMP(cop) && OP_SYMBOL((*op))->isreqv) {
     operand **rop = &OP_SYMBOL((*op))->usl.spillLoc->reqv;
@@ -107,7 +163,7 @@ void ReplaceOpWithCheaperOp(operand **op, operand *cop) {
 /* replaceAllSymBySym - replaces all operands by operand in an     */
 /*                      instruction chain                          */
 /*-----------------------------------------------------------------*/
-void 
+void
 replaceAllSymBySym (iCode * ic, operand * from, operand * to, bitVect ** ndpset)
 {
   iCode *lic;
@@ -281,7 +337,7 @@ DEFSETFUNC (findCheaperOp)
 	/* if the result is volatile then return result */
 	if (IS_OP_VOLATILE (IC_RESULT (cdp->diCode)))
 	  *opp = IC_RESULT (cdp->diCode);
-	else 
+	else
 	  /* if this is a straight assignment and
 	     left is a temp then prefer the temporary to the
 	     true symbol */
@@ -325,8 +381,8 @@ DEFSETFUNC (findCheaperOp)
       IS_ITEMP (IC_RESULT (cdp->diCode)))
     *opp = IC_RESULT (cdp->diCode);
 
-  if ((*opp) && 
-      (isOperandLiteral(*opp) || !checkSign || 
+  if ((*opp) &&
+      (isOperandLiteral(*opp) || !checkSign ||
        (checkSign &&
 	IS_SPEC(operandType (cop)) && IS_SPEC(operandType (*opp)) &&
 	(SPEC_USIGN(operandType (cop))==SPEC_USIGN(operandType (*opp)) &&
@@ -353,11 +409,11 @@ DEFSETFUNC (findCheaperOp)
 	  *opp = operandFromOperand (*opp);
 	  (*opp)->isaddr = cop->isaddr;
 	}
-	  
+
       if (IS_SPEC(operandType (cop)) && IS_SPEC(operandType (*opp)) &&
 	  SPEC_NOUN(operandType(cop)) != SPEC_NOUN(operandType(*opp)))
 	{
-	    // special case: we can make an unsigned char literal 
+	    // special case: we can make an unsigned char literal
 	    // into an int literal with no cost.
 	    if (isOperandLiteral(*opp)
 	     && SPEC_NOUN(operandType(*opp)) == V_CHAR
@@ -372,9 +428,9 @@ DEFSETFUNC (findCheaperOp)
 		*opp = NULL;
 		return 0;
 	    }
-	    
+
         }
-	  
+
       return 1;
 
     }
@@ -456,6 +512,16 @@ DEFSETFUNC (ifAssignedFromGlobal)
   return 0;
 }
 
+/*-------------------------------------------------------------------*/
+/* ifFromGlobal - if definition is derived from global               */
+/*-------------------------------------------------------------------*/
+DEFSETFUNC (ifFromGlobal)
+{
+  cseDef *cdp = item;
+  
+  return cdp->fromGlobal;
+}
+
 /*-----------------------------------------------------------------*/
 /* ifDefGlobal - if definition is global                           */
 /*-----------------------------------------------------------------*/
@@ -486,7 +552,9 @@ DEFSETFUNC (ifOperandsHave)
   cseDef *cdp = item;
   V_ARG (operand *, op);
 
-
+  if (bitVectBitValue(cdp->ancestors, op->key))
+    return 1;
+  
   if (IC_LEFT (cdp->diCode) &&
       IS_SYMOP (IC_LEFT (cdp->diCode)) &&
       IC_LEFT (cdp->diCode)->key == op->key)
@@ -517,7 +585,7 @@ DEFSETFUNC (ifOperandsHave)
 /*-----------------------------------------------------------------*/
 /* ifDefSymIs - if a definition is found in the set                */
 /*-----------------------------------------------------------------*/
-int 
+int
 ifDefSymIs (set * cseSet, operand * sym)
 {
   cseDef *loop;
@@ -542,19 +610,24 @@ DEFSETFUNC (ifDefSymIsX)
 {
   cseDef *cdp = item;
   V_ARG (operand *, op);
-
+  int match;
+  
   if (op && cdp->sym)
-    return cdp->sym->key == op->key;
+    match = cdp->sym->key == op->key;
   else
-    return (isOperandEqual (cdp->sym, op));
-
+    match = (isOperandEqual (cdp->sym, op));
+  #if 0
+  if (match)
+    printf("%s ",OP_SYMBOL(cdp->sym)->name);
+  #endif
+  return match;
 }
 
 
 /*-----------------------------------------------------------------*/
 /* ifDiCodeIs - returns truw if diCode is same                     */
 /*-----------------------------------------------------------------*/
-int 
+int
 ifDiCodeIs (set * cseSet, iCode * ic)
 {
   cseDef *loop;
@@ -624,7 +697,7 @@ iCode *findBackwardDef(operand *op,iCode *ic)
     iCode *lic;
 
     for (lic = ic; lic ; lic = lic->prev) {
-	if (IC_RESULT(lic) && isOperandEqual(op,IC_RESULT(lic))) 
+	if (IC_RESULT(lic) && isOperandEqual(op,IC_RESULT(lic)))
 	    return lic;
     }
     return NULL;
@@ -633,8 +706,8 @@ iCode *findBackwardDef(operand *op,iCode *ic)
 /*-----------------------------------------------------------------*/
 /* algebraicOpts - does some algebraic optimizations               */
 /*-----------------------------------------------------------------*/
-void 
-algebraicOpts (iCode * ic)
+static void
+algebraicOpts (iCode * ic, eBBlock * ebp)
 {
   /* we don't deal with the following iCodes
      here */
@@ -735,13 +808,21 @@ algebraicOpts (iCode * ic)
 	  return;
 	}
       /* if addition then check if one of them is a zero */
-      /* if yes turn it  into assignmnt */
+      /* if yes turn it into assignmnt or cast */
       if (IS_OP_LITERAL (IC_LEFT (ic)) &&
 	  operandLitValue (IC_LEFT (ic)) == 0.0)
 	{
-
-	  ic->op = '=';
-	  IC_LEFT (ic) = NULL;
+	  if (compareType (operandType (IC_RESULT (ic)),
+			   operandType (IC_RIGHT (ic)))<0)
+	    {
+	      ic->op = CAST;
+	      IC_LEFT (ic) = operandFromLink (operandType (IC_RESULT (ic)));
+	    }
+	  else
+            {
+	      ic->op = '=';
+	      IC_LEFT (ic) = NULL;
+            }
 	  SET_ISADDR (IC_RESULT (ic), 0);
 	  SET_ISADDR (IC_RIGHT (ic), 0);
 	  return;
@@ -749,10 +830,19 @@ algebraicOpts (iCode * ic)
       if (IS_OP_LITERAL (IC_RIGHT (ic)) &&
 	  operandLitValue (IC_RIGHT (ic)) == 0.0)
 	{
-
-	  ic->op = '=';
-	  IC_RIGHT (ic) = IC_LEFT (ic);
-	  IC_LEFT (ic) = 0;
+	  if (compareType (operandType (IC_RESULT (ic)),
+			   operandType (IC_LEFT (ic)))<0)
+	    {
+	      ic->op = CAST;
+	      IC_RIGHT (ic) = IC_LEFT (ic);
+	      IC_LEFT (ic) = operandFromLink (operandType (IC_RESULT (ic)));
+	    }
+	  else
+            {
+	      ic->op = '=';
+	      IC_RIGHT (ic) = IC_LEFT (ic);
+	      IC_LEFT (ic) = NULL;
+            }
 	  SET_ISADDR (IC_RIGHT (ic), 0);
 	  SET_ISADDR (IC_RESULT (ic), 0);
 	  return;
@@ -812,9 +902,23 @@ algebraicOpts (iCode * ic)
 	    }
 	  if (operandLitValue (IC_LEFT (ic)) == 1.0)
 	    {
-	      ic->op = '=';
-	      IC_LEFT (ic) = NULL;
-	      SET_RESULT_RIGHT (ic);
+	      /* '*' can have two unsigned chars as operands */
+	      /* and an unsigned int as result.              */
+	      if (compareType (operandType (IC_RESULT (ic)),
+			       operandType (IC_RIGHT (ic))) == 1)
+		{
+		  ic->op = '=';
+		  IC_LEFT (ic) = NULL;
+		  SET_RESULT_RIGHT (ic);
+		}
+	      else
+		{
+	          ic->op = CAST;
+		  IC_LEFT (ic) = operandFromOperand (IC_LEFT (ic));
+		  IC_LEFT (ic)->type = TYPE;
+		  IC_LEFT (ic)->isLiteral = 0;
+		  setOperandType (IC_LEFT (ic), operandType (IC_RESULT (ic)));
+		}
 	      return;
 	    }
 	}
@@ -832,10 +936,28 @@ algebraicOpts (iCode * ic)
 
 	  if (operandLitValue (IC_RIGHT (ic)) == 1.0)
 	    {
-	      ic->op = '=';
-	      IC_RIGHT (ic) = IC_LEFT (ic);
-	      IC_LEFT (ic) = NULL;
-	      SET_RESULT_RIGHT (ic);
+	      /* '*' can have two unsigned chars as operands */
+	      /* and an unsigned int as result.              */
+	      if (compareType (operandType (IC_RESULT (ic)),
+			       operandType (IC_LEFT (ic))) == 1)
+		{
+		  ic->op = '=';
+		  IC_RIGHT (ic) = IC_LEFT (ic);
+		  IC_LEFT (ic) = NULL;
+		  SET_RESULT_RIGHT (ic);
+	        }
+	      else
+	        {
+                  operand *op;
+
+	          ic->op = CAST;
+		  op = IC_RIGHT (ic);
+		  IC_RIGHT (ic) = IC_LEFT (ic);
+		  IC_LEFT (ic) = operandFromOperand (op);
+		  IC_LEFT (ic)->type = TYPE;
+		  IC_LEFT (ic)->isLiteral = 0;
+		  setOperandType (IC_LEFT (ic), operandType (IC_RESULT (ic)));
+	        }
 	      return;
 	    }
 	}
@@ -920,6 +1042,201 @@ algebraicOpts (iCode * ic)
 	  IC_LEFT (ic) = NULL;
 	  SET_ISADDR (IC_RESULT (ic), 0);
 	}
+      break;
+    case BITWISEAND:
+      /* if both operands are equal */
+      /* if yes turn it into assignment */
+      if (isOperandEqual (IC_LEFT (ic), IC_RIGHT (ic)))
+        {
+          if (IS_OP_VOLATILE (IC_LEFT (ic)))
+	    {
+	      iCode *newic = newiCode (DUMMY_READ_VOLATILE, NULL, IC_LEFT (ic));
+	      IC_RESULT (newic) = IC_LEFT (ic);
+	      newic->lineno = ic->lineno;
+	      addiCodeToeBBlock (ebp, newic, ic->next);
+	    }
+	  ic->op = '=';
+	  IC_LEFT (ic) = NULL;
+	  SET_RESULT_RIGHT (ic);
+	  return;
+	}
+      /* swap literal to right ic */
+      if (IS_OP_LITERAL (IC_LEFT (ic)))
+        {
+	  operand *op;
+
+	  op = IC_LEFT (ic);
+	  IC_LEFT (ic) = IC_RIGHT (ic);
+	  IC_RIGHT (ic) = op;
+	}
+      if (IS_OP_LITERAL (IC_RIGHT (ic)))
+        {
+	  /* if BITWISEAND then check if one of them is a zero */
+	  /* if yes turn it into 0 assignment */
+	  if (operandLitValue (IC_RIGHT (ic)) == 0.0)
+	    {
+	      if (IS_OP_VOLATILE (IC_LEFT (ic)))
+		{
+		  iCode *newic = newiCode (DUMMY_READ_VOLATILE, NULL, IC_LEFT (ic));
+		  IC_RESULT (newic) = IC_LEFT (ic);
+		  newic->lineno = ic->lineno;
+		  addiCodeToeBBlock (ebp, newic, ic->next);
+		}
+	      ic->op = '=';
+	      IC_LEFT (ic) = NULL;
+	      SET_RESULT_RIGHT (ic);
+	      return;
+	    }
+	  /* if BITWISEAND then check if one of them is 0xff... */
+	  /* if yes turn it into assignment */
+	  {
+	    unsigned val;
+
+	    switch (getSize (operandType (IC_RIGHT (ic))))
+	      {
+	      case 1:
+	        val = 0xff;
+		break;
+	      case 2:
+	        val = 0xffff;
+		break;
+	      case 4:
+	        val = 0xffffffff;
+		break;
+	      default:
+	        return;
+	      }
+	    if (((unsigned) operandLitValue (IC_RIGHT (ic)) & val) == val)
+	    {
+	      ic->op = '=';
+	      IC_RIGHT (ic) = IC_LEFT (ic);
+	      IC_LEFT (ic) = NULL;
+	      SET_RESULT_RIGHT (ic);
+	      return;
+	    }
+	  }
+	}
+      break;
+    case '|':
+      /* if both operands are equal */
+      /* if yes turn it into assignment */
+      if (isOperandEqual (IC_LEFT (ic), IC_RIGHT (ic)))
+        {
+          if (IS_OP_VOLATILE (IC_LEFT (ic)))
+	    {
+	      iCode *newic = newiCode (DUMMY_READ_VOLATILE, NULL, IC_LEFT (ic));
+	      IC_RESULT (newic) = IC_LEFT (ic);
+	      newic->lineno = ic->lineno;
+	      addiCodeToeBBlock (ebp, newic, ic->next);
+	    }
+	    ic->op = '=';
+	    IC_LEFT (ic) = NULL;
+	    SET_RESULT_RIGHT (ic);
+	    return;
+	}
+      /* swap literal to right ic */
+      if (IS_OP_LITERAL (IC_LEFT (ic)))
+        {
+	  operand *op;
+
+	  op = IC_LEFT (ic);
+	  IC_LEFT (ic) = IC_RIGHT (ic);
+	  IC_RIGHT (ic) = op;
+	}
+      if (IS_OP_LITERAL (IC_RIGHT (ic)))
+        {
+	  /* if BITWISEOR then check if one of them is a zero */
+	  /* if yes turn it into assignment */
+	  if (operandLitValue (IC_RIGHT (ic)) == 0.0)
+	    {
+	      ic->op = '=';
+	      IC_RIGHT (ic) = IC_LEFT (ic);
+	      IC_LEFT (ic) = NULL;
+	      SET_RESULT_RIGHT (ic);
+	      return;
+	    }
+	  /* if BITWISEOR then check if one of them is 0xff... */
+	  /* if yes turn it into 0xff... assignment */
+	  {
+	    unsigned val;
+
+	    switch (getSize (operandType (IC_RIGHT (ic))))
+	      {
+	      case 1:
+	        val = 0xff;
+		break;
+	      case 2:
+	        val = 0xffff;
+		break;
+	      case 4:
+	        val = 0xffffffff;
+		break;
+	      default:
+	        return;
+	      }
+	    if (((unsigned) operandLitValue (IC_RIGHT (ic)) & val) == val)
+	      {
+		if (IS_OP_VOLATILE (IC_LEFT (ic)))
+		{
+		  iCode *newic = newiCode (DUMMY_READ_VOLATILE, NULL, IC_LEFT (ic));
+		  IC_RESULT (newic) = IC_LEFT (ic);
+		  newic->lineno = ic->lineno;
+		  addiCodeToeBBlock (ebp, newic, ic->next);
+		}
+		ic->op = '=';
+		IC_LEFT (ic) = NULL;
+		SET_RESULT_RIGHT (ic);
+		return;
+	      }
+	  }
+	}
+      break;
+    case '^':
+      /* if both operands are equal */
+      /* if yes turn it into 0 assignment */
+      if (isOperandEqual (IC_LEFT (ic), IC_RIGHT (ic)))
+        {
+          if (IS_OP_VOLATILE (IC_LEFT (ic)))
+	    {
+	      iCode *newic = newiCode (DUMMY_READ_VOLATILE, NULL, IC_LEFT (ic));
+	      IC_RESULT (newic) = IC_LEFT (ic);
+	      newic->lineno = ic->lineno;
+	      addiCodeToeBBlock (ebp, newic, ic->next);
+
+	      newic = newiCode (DUMMY_READ_VOLATILE, NULL, IC_LEFT (ic));
+	      IC_RESULT (newic) = IC_LEFT (ic);
+	      newic->lineno = ic->lineno;
+	      addiCodeToeBBlock (ebp, newic, ic->next);
+	    }
+	    ic->op = '=';
+	    IC_RIGHT (ic) = operandFromLit (0);
+	    IC_LEFT (ic) = NULL;
+	    SET_RESULT_RIGHT (ic);
+	    return;
+	}
+      /* swap literal to right ic */
+      if (IS_OP_LITERAL (IC_LEFT (ic)))
+        {
+	  operand *op;
+
+	  op = IC_LEFT (ic);
+	  IC_LEFT (ic) = IC_RIGHT (ic);
+	  IC_RIGHT (ic) = op;
+	}
+      /* if XOR then check if one of them is a zero */
+      /* if yes turn it into assignment */
+      if (IS_OP_LITERAL (IC_RIGHT (ic)))
+	{
+	  if (operandLitValue (IC_RIGHT (ic)) == 0.0)
+	    {
+	      ic->op = '=';
+	      IC_RIGHT (ic) = IC_LEFT (ic);
+	      IC_LEFT (ic) = NULL;
+	      SET_RESULT_RIGHT (ic);
+	      return;
+	    }
+	}
+      break;
     }
 
   return;
@@ -928,7 +1245,7 @@ algebraicOpts (iCode * ic)
 /*-----------------------------------------------------------------*/
 /* updateSpillLocation - keeps track of register spill location    */
 /*-----------------------------------------------------------------*/
-void 
+void
 updateSpillLocation (iCode * ic, int induction)
 {
 	sym_link *setype;
@@ -939,6 +1256,7 @@ updateSpillLocation (iCode * ic, int induction)
 	if (ic->nosupdate)
 		return;
 
+#if 0
 	/* for the form true_symbol := iTempNN */
 	if (ASSIGN_ITEMP_TO_SYM (ic) && 
 	    !SPIL_LOC (IC_RIGHT (ic))) {
@@ -957,6 +1275,7 @@ updateSpillLocation (iCode * ic, int induction)
 		}
 	    
 	}
+#endif
 
 #if 0 /* this needs furthur investigation can save a lot of code */
 	if (ASSIGN_SYM_TO_ITEMP(ic) &&
@@ -1106,7 +1425,7 @@ ifxOptimize (iCode * ic, set * cseSet,
       /* the price */
       computeControlFlow (ebbs, count, 1);
       if (!options.lessPedantic) {
-	werror (W_CONTROL_FLOW, ic->filename, ic->lineno);
+	werrorfl (ic->filename, ic->lineno, W_CONTROL_FLOW);
       }
       return;
     }
@@ -1119,18 +1438,36 @@ ifxOptimize (iCode * ic, set * cseSet,
       isinSet (ebb->succList, eBBWithEntryLabel (ebbs, label, count)))
     {
 
-      remiCodeFromeBBlock (ebb, ic);
-      computeControlFlow (ebbs, count, 1);
       if (!options.lessPedantic) {
-	werror (W_CONTROL_FLOW, ic->filename, ic->lineno);
+	werrorfl (ic->filename, ic->lineno, W_CONTROL_FLOW);
       }
-      return;
+      if (IS_OP_VOLATILE (IC_COND (ic)))
+	{
+	  IC_RIGHT (ic) = IC_COND (ic);
+	  IC_LEFT (ic) = NULL;
+	  IC_RESULT (ic) = NULL;
+	  ic->op = DUMMY_READ_VOLATILE;
+	}
+      else
+        {
+	  remiCodeFromeBBlock (ebb, ic);
+	  computeControlFlow (ebbs, count, 1);
+	  return;
+	}      
     }
 
 
   /* if it remains an IFX the update the use Set */
-  OP_USES(IC_COND (ic))=bitVectSetBit (OP_USES (IC_COND (ic)), ic->key);
-  setUsesDefs (IC_COND (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
+  if (ic->op == IFX)
+    {
+      OP_USES(IC_COND (ic))=bitVectSetBit (OP_USES (IC_COND (ic)), ic->key);
+      setUsesDefs (IC_COND (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
+    }
+  else if (ic->op == DUMMY_READ_VOLATILE)
+    {
+      OP_USES(IC_RIGHT (ic))=bitVectSetBit (OP_USES (IC_RIGHT (ic)), ic->key);
+      setUsesDefs (IC_RIGHT (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
+    }
   return;
 }
 
@@ -1239,50 +1576,52 @@ deleteGetPointers (set ** cseSet, set ** pss, operand * op, eBBlock * ebb)
   set *compItems = NULL;
   cseDef *cdp;
   operand *cop;
+  int changes;
 
   /* easy return */
   if (!*cseSet && !*pss)
     return;
 
-  /* first find all items computed from this operand .
+  addSet (&compItems, op);
+  
+  /* Recursively find all items computed from this operand .
      This done fairly simply go thru the list and find
-     those that are computed by arthimetic with this
-     op */
-  for (cdp = setFirstItem (*cseSet); cdp; cdp = setNextItem (*cseSet))
+     those that are computed by arthimetic with these
+     ops */
+  /* Also check for those computed from our computed
+     list . This will take care of situations like
+     iTemp1 = iTemp0 + 8;
+     iTemp2 = iTemp1 + 8; */
+  do
     {
-      if (IS_ARITHMETIC_OP (cdp->diCode))
+      changes = 0;
+      for (cdp = setFirstItem (*cseSet); cdp; cdp = setNextItem (*cseSet))
 	{
-	  if (isOperandEqual (IC_LEFT (cdp->diCode), op) ||
-	      isOperandEqual (IC_RIGHT (cdp->diCode), op))
-	    {
-	      /* save it in our list of items */
-	      addSet (&compItems, IC_RESULT (cdp->diCode));
-	    }
-	  /* also check for those computed from our computed
-	     list . This will take care of situations like
-	     iTemp1 = iTemp0 + 8;
-	     iTemp2 = iTemp1 + 8; */
-	  if (isinSetWith (compItems, (void*)IC_LEFT (cdp->diCode), 
-			   (insetwithFunc)isOperandEqual) ||
-	      isinSetWith (compItems, (void*)IC_RIGHT (cdp->diCode), 
-			   (insetwithFunc)isOperandEqual))
+	  if (IS_ARITHMETIC_OP (cdp->diCode) || POINTER_GET(cdp->diCode))
 	    {
-	      addSet (&compItems, IC_RESULT (cdp->diCode));
+	      if (isinSetWith (compItems, (void*)IC_LEFT (cdp->diCode),
+			       (insetwithFunc)isOperandEqual) ||
+		  isinSetWith (compItems, (void*)IC_RIGHT (cdp->diCode),
+			       (insetwithFunc)isOperandEqual))
+		{
+		  if (!isinSetWith (compItems, (void*)IC_RESULT (cdp->diCode),
+			            (insetwithFunc)isOperandEqual))
+		    {
+		  addSet (&compItems, IC_RESULT (cdp->diCode));
+		  changes++;
+		    }
+		}
 	    }
 	}
     }
-
-  /* now delete all pointer gets with this op */
-  deleteItemIf (cseSet, ifPointerGet, op);
-  deleteItemIf (pss, ifPointerSet, op);
-
-  /* set the bit vector used by dataFlow computation later */
-  ebb->ptrsSet = bitVectSetBit (ebb->ptrsSet, op->key);
+  while (changes);
+  
   /* now for the computed items */
   for (cop = setFirstItem (compItems); cop; cop = setNextItem (compItems))
     {
       ebb->ptrsSet = bitVectSetBit (ebb->ptrsSet, cop->key);
       deleteItemIf (cseSet, ifPointerGet, cop);
+      deleteItemIf (cseSet, ifDefSymIsX, cop);
       deleteItemIf (pss, ifPointerSet, cop);
     }
 }
@@ -1312,7 +1651,7 @@ DEFSETFUNC (delGetPointerSucc)
 /*-----------------------------------------------------------------*/
 /* fixUpTypes - KLUGE HACK fixup a lowering problem                */
 /*-----------------------------------------------------------------*/
-static void 
+static void
 fixUpTypes (iCode * ic)
 {
   sym_link *t1 = operandType (IC_LEFT (ic)), *t2;
@@ -1383,13 +1722,29 @@ static int isSignedOp (iCode *ic)
     }
  }
 
+#if 0
+static void
+dumpCseSet(set *cseSet)
+{
+  while (cseSet)
+    {
+      cseDef *item=cseSet->item;
+      printf("->");
+      printOperand (item->sym, NULL);
+      printf("  ");
+      piCode (item->diCode, NULL);
+      cseSet = cseSet->next;
+    }
+}
+#endif
+
 /*-----------------------------------------------------------------*/
 /* cseBBlock - common subexpression elimination for basic blocks   */
 /*             this is the hackiest kludgiest routine in the whole */
 /*             system. also the most important, since almost all   */
 /*             data flow related information is computed by it     */
 /*-----------------------------------------------------------------*/
-int 
+int
 cseBBlock (eBBlock * ebb, int computeOnly,
 	   eBBlock ** ebbs, int count)
 {
@@ -1398,6 +1753,7 @@ cseBBlock (eBBlock * ebb, int computeOnly,
   int change = 0;
   int i;
   set *ptrSetSet = NULL;
+  cseDef *expr;
 
   /* if this block is not reachable */
   if (ebb->noPath)
@@ -1407,12 +1763,12 @@ cseBBlock (eBBlock * ebb, int computeOnly,
   cseSet = setFromSet (ebb->inExprs);
 
   /* these will be computed by this routine */
-  setToNull ((void **) &ebb->outDefs);
-  setToNull ((void **) &ebb->defSet);
-  setToNull ((void **) &ebb->usesDefs);
-  setToNull ((void **) &ebb->ptrsSet);
-  setToNull ((void **) &ebb->addrOf);
-  setToNull ((void **) &ebb->ldefs);
+  setToNull ((void *) &ebb->outDefs);
+  setToNull ((void *) &ebb->defSet);
+  setToNull ((void *) &ebb->usesDefs);
+  setToNull ((void *) &ebb->ptrsSet);
+  setToNull ((void *) &ebb->addrOf);
+  setToNull ((void *) &ebb->ldefs);
 
   ebb->outDefs = bitVectCopy (ebb->inDefs);
   bitVectDefault = iCodeKey;
@@ -1438,7 +1794,7 @@ cseBBlock (eBBlock * ebb, int computeOnly,
 	  IS_PTR (operandType (IC_RESULT (ic))))
 	{
 	  ptrPostIncDecOpt (ic);
-	}
+	}        
 
       /* clear the def & use chains for the operands involved */
       /* in this operation . since it can change due to opts  */
@@ -1458,13 +1814,16 @@ cseBBlock (eBBlock * ebb, int computeOnly,
 	     since they can be modified by the function call */
 	  deleteItemIf (&cseSet, ifDefGlobal);
 
-	  /* and also itemps assigned from globals */
-	  deleteItemIf (&cseSet, ifAssignedFromGlobal);
+	  /* and also itemps derived from globals */
+	  deleteItemIf (&cseSet, ifFromGlobal);
 
 	  /* delete all getpointer iCodes from cseSet, this should
 	     be done only for global arrays & pointers but at this
 	     point we don't know if globals, so to be safe do all */
 	  deleteItemIf (&cseSet, ifAnyGetPointer);
+          
+          /* can't cache pointer set/get operations across a call */
+          deleteSet (&ptrSetSet);
 	}
 
       /* for pcall & ipush we need to add to the useSet */
@@ -1511,10 +1870,13 @@ cseBBlock (eBBlock * ebb, int computeOnly,
       /* if jumptable then mark the usage */
       if (ic->op == JUMPTABLE)
 	{
-	  OP_USES(IC_JTCOND (ic))=
-	    bitVectSetBit (OP_USES (IC_JTCOND (ic)), ic->key);
-	  setUsesDefs (IC_JTCOND (ic), ebb->defSet,
-		       ebb->outDefs, &ebb->usesDefs);
+          if (IS_SYMOP (IC_JTCOND (ic)))
+	    {
+	      OP_USES(IC_JTCOND (ic)) =
+	        bitVectSetBit (OP_USES (IC_JTCOND (ic)), ic->key);
+	      setUsesDefs (IC_JTCOND (ic), ebb->defSet,
+		           ebb->outDefs, &ebb->usesDefs);
+	    }
 	  continue;
 	}
 
@@ -1523,7 +1885,7 @@ cseBBlock (eBBlock * ebb, int computeOnly,
 
       if (!computeOnly) {
 	/* do some algebraic optimizations if possible */
-	algebraicOpts (ic);
+	algebraicOpts (ic, ebb);
 	while (constFold (ic, cseSet));
       }
 
@@ -1541,9 +1903,9 @@ cseBBlock (eBBlock * ebb, int computeOnly,
 			  aggrToPtr (operandType (IC_RESULT (ic)), FALSE));
 	}
 
-      /* if this is a condition statment then */
+      /* if this is a condition statement then */
       /* check if the condition can be replaced */
-      if (!computeOnly && ic->op == IFX)
+      if (ic->op == IFX)
 	{
 	  ifxOptimize (ic, cseSet, computeOnly,
 		       ebb, &change,
@@ -1564,7 +1926,8 @@ cseBBlock (eBBlock * ebb, int computeOnly,
 	    {
 	      pdop = NULL;
 	      applyToSetFTrue (cseSet, findCheaperOp, IC_RESULT (ic), &pdop, 0);
-	      if (pdop && IS_ITEMP (pdop) && !computeOnly)
+	      if (pdop && !computeOnly &&
+		  IS_ITEMP (pdop) && IS_PTR(operandType(pdop)))
 		ReplaceOpWithCheaperOp (&IC_RESULT(ic), pdop);
 	    }
 	}
@@ -1629,11 +1992,11 @@ cseBBlock (eBBlock * ebb, int computeOnly,
 	    change = 1;
 	  }
 	}
-	
+
       /* if left or right changed then do algebraic */
-      if (change)
+      if (!computeOnly && change)
 	{
-	  algebraicOpts (ic);
+	  algebraicOpts (ic, ebb);
 	  while (constFold (ic, cseSet));
 	}
 
@@ -1664,15 +2027,15 @@ cseBBlock (eBBlock * ebb, int computeOnly,
 	  if (pdic && compareType (operandType (IC_RESULT (pdic)),
 				 operandType (IC_RESULT (ic))) != 1)
 	    pdic = NULL;
-	  if (pdic && port->cseOk && (*port->cseOk)(ic,pdic) == 0) 
+	  if (pdic && port->cseOk && (*port->cseOk)(ic,pdic) == 0)
 	      pdic = NULL;
 	}
 
       /* Alternate code */
       if (pdic && IS_ITEMP(IC_RESULT(ic))) {
 	if (POINTER_GET(ic) && bitVectBitValue(ebb->ptrsSet,IC_LEFT(ic)->key)) {
-	  /* Mmm, found an equivalent pointer get at a lower level. 
-	     This could be a loop however with the same pointer set 
+	  /* Mmm, found an equivalent pointer get at a lower level.
+	     This could be a loop however with the same pointer set
 	     later on */
 	} else {
 	  /* if previous definition found change this to an assignment */
@@ -1680,13 +2043,16 @@ cseBBlock (eBBlock * ebb, int computeOnly,
 	  IC_LEFT(ic) = NULL;
 	  IC_RIGHT(ic) = operandFromOperand(IC_RESULT(pdic));
 	  SET_ISADDR(IC_RESULT(ic),0);
-	  SET_ISADDR(IC_RIGHT (ic),0);	  
+	  SET_ISADDR(IC_RIGHT (ic),0);
 	}
       }
 
       if (!(POINTER_SET (ic)) && IC_RESULT (ic)) {
+          cseDef *csed;
 	  deleteItemIf (&cseSet, ifDefSymIsX, IC_RESULT (ic));
-	  addSetHead (&cseSet, newCseDef (IC_RESULT (ic), ic));
+          csed = newCseDef (IC_RESULT (ic), ic);
+          updateCseDefAncestors (csed, cseSet);
+	  addSetHead (&cseSet, csed);
       }
       defic = ic;
 
@@ -1788,7 +2154,12 @@ cseBBlock (eBBlock * ebb, int computeOnly,
 	}
     }
 
-  setToNull ((void **) &ebb->outExprs);
+  for (expr=setFirstItem (ebb->inExprs); expr; expr=setNextItem (ebb->inExprs))
+    if (!isinSetWith (cseSet, expr, isCseDefEqual) &&
+        !isinSetWith (ebb->killedExprs, expr, isCseDefEqual)) {
+    addSetHead (&ebb->killedExprs, expr);
+  }
+  setToNull ((void *) &ebb->outExprs);
   ebb->outExprs = cseSet;
   ebb->outDefs = bitVectUnion (ebb->outDefs, ebb->defSet);
   ebb->ptrsSet = bitVectUnion (ebb->ptrsSet, ebb->inPtrsSet);
@@ -1798,7 +2169,7 @@ cseBBlock (eBBlock * ebb, int computeOnly,
 /*-----------------------------------------------------------------*/
 /* cseAllBlocks - will sequentially go thru & do cse for all blocks */
 /*-----------------------------------------------------------------*/
-int 
+int
 cseAllBlocks (eBBlock ** ebbs, int count, int computeOnly)
 {
   int i;