1 /*-------------------------------------------------------------------------
2 SDCCcse.c - source file for Common Subexpressions and other utility
4 Written By - Sandeep Dutta . sandeep.dutta@usa.net (1998)
6 This program is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 2, or (at your option) any
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20 In other words, you are welcome to use, share and improve this program.
21 You are forbidden to forbid anyone else to use, share and improve
22 what you give them. Help stamp out software-hoarding!
23 -------------------------------------------------------------------------*/
28 /*-----------------------------------------------------------------*/
29 /* newCseDef - new cseDef */
30 /*-----------------------------------------------------------------*/
32 newCseDef (operand * sym, iCode * ic)
37 cdp = Safe_calloc (1, sizeof (cseDef));
48 /*-----------------------------------------------------------------*/
49 /* int isCseDefEqual - two definitions are equal */
50 /*-----------------------------------------------------------------*/
52 isCseDefEqual (void *vsrc, void *vdest)
60 return (src->key == dest->key &&
61 src->diCode == dest->diCode);
65 /*-----------------------------------------------------------------*/
66 /* pcseDef - in the cseDef */
67 /*-----------------------------------------------------------------*/
69 pcseDef (void *item, va_list ap)
77 fprintf (stdout, "**null op**");
78 printOperand (cdp->sym, stdout);
79 icTab = getTableEntry (cdp->diCode->op);
80 icTab->iCodePrint (stdout, cdp->diCode, icTab->printName);
84 /*-----------------------------------------------------------------*/
85 /* replaceAllSymBySym - replaces all operands by operand in an */
86 /* instruction chain */
87 /*-----------------------------------------------------------------*/
89 replaceAllSymBySym (iCode * ic, operand * from, operand * to, bitVect ** ndpset)
93 for (lic = ic; lic; lic = lic->next)
97 /* do the special cases first */
101 IC_COND (lic)->key == from->key)
104 bitVectUnSetBit (OP_USES (from), lic->key);
105 OP_USES (to) = bitVectSetBit (OP_USES (to), lic->key);
106 siaddr = IC_COND (lic)->isaddr;
107 IC_COND (lic) = operandFromOperand (to);
108 IC_COND (lic)->isaddr = siaddr;
114 if (lic->op == JUMPTABLE)
117 IC_JTCOND (lic)->key == from->key)
120 bitVectUnSetBit (OP_USES (from), lic->key);
121 OP_USES (to) = bitVectSetBit (OP_USES (to), lic->key);
122 siaddr = IC_COND (lic)->isaddr;
123 IC_JTCOND (lic) = operandFromOperand (to);
124 IC_JTCOND (lic)->isaddr = siaddr;
130 if (IC_RESULT (lic) && IC_RESULT (lic)->key == from->key)
132 /* maintain du chains */
133 if (POINTER_SET (lic))
135 bitVectUnSetBit (OP_USES (from), lic->key);
136 OP_USES (to) = bitVectSetBit (OP_USES (to), lic->key);
138 /* also check if the "from" was in the non-dominating
139 pointer sets and replace it with "to" in the bitVector */
140 if (bitVectBitValue (*ndpset, from->key))
142 bitVectUnSetBit (*ndpset, from->key);
143 bitVectSetBit (*ndpset, to->key);
149 bitVectUnSetBit (OP_DEFS (from), lic->key);
150 OP_DEFS (to) = bitVectSetBit (OP_DEFS (to), lic->key);
152 siaddr = IC_RESULT (lic)->isaddr;
153 IC_RESULT (lic) = operandFromOperand (to);
154 IC_RESULT (lic)->isaddr = siaddr;
158 IC_RIGHT (lic) && IC_RIGHT (lic)->key == from->key)
160 bitVectUnSetBit (OP_USES (from), lic->key);
161 OP_USES (to) = bitVectSetBit (OP_USES (to), lic->key);
162 siaddr = IC_RIGHT (lic)->isaddr;
163 IC_RIGHT (lic) = operandFromOperand (to);
164 IC_RIGHT (lic)->isaddr = siaddr;
168 IC_LEFT (lic) && IC_LEFT (lic)->key == from->key)
170 bitVectUnSetBit (OP_USES (from), lic->key);
171 OP_USES (to) = bitVectSetBit (OP_USES (to), lic->key);
172 siaddr = IC_LEFT (lic)->isaddr;
173 IC_LEFT (lic) = operandFromOperand (to);
174 IC_LEFT (lic)->isaddr = siaddr;
179 /*-----------------------------------------------------------------*/
180 /* iCodeKeyIs - if the icode keys match then return 1 */
181 /*-----------------------------------------------------------------*/
182 DEFSETFUNC (iCodeKeyIs)
187 if (cdp->diCode->key == key)
193 /*-----------------------------------------------------------------*/
194 /* removeFromInExprs - removes an icode from inexpressions */
195 /*-----------------------------------------------------------------*/
196 DEFSETFUNC (removeFromInExprs)
200 V_ARG (operand *, from);
201 V_ARG (operand *, to);
202 V_ARG (eBBlock *, cbp);
208 deleteItemIf (&ebp->inExprs, iCodeKeyIs, ic->key);
209 if (ebp != cbp && !bitVectBitValue (cbp->domVect, ebp->bbnum))
210 replaceAllSymBySym (ebp->sch, from, to, &ebp->ndompset);
212 applyToSet (ebp->succList, removeFromInExprs, ic, from, to, cbp);
216 /*-----------------------------------------------------------------*/
217 /* isGlobalInNearSpace - return TRUE if valriable is a globalin data */
218 /*-----------------------------------------------------------------*/
220 isGlobalInNearSpace (operand * op)
222 sym_link *type = getSpec (operandType (op));
223 /* this is 8051 specific: optimization
224 suggested by Jean-Louis VERN, with 8051s we have no
225 advantage of putting variables in near space into
227 if (isOperandGlobal (op) && !IN_FARSPACE (SPEC_OCLS (type)) &&
228 IN_DIRSPACE (SPEC_OCLS (type)))
234 /*-----------------------------------------------------------------*/
235 /* findCheaperOp - cseBBlock support routine, will check to see if */
236 /* we have a operand previously defined */
237 /*-----------------------------------------------------------------*/
238 DEFSETFUNC (findCheaperOp)
241 V_ARG (operand *, cop);
242 V_ARG (operand **, opp);
244 /* if we have already found it */
248 /* not found it yet check if this is the one */
249 /* and this is not the defining one */
250 if (cop->key == cdp->key)
253 /* do a special check this will help in */
254 /* constant propagation & dead code elim */
255 /* for assignments only */
256 if (cdp->diCode->op == '=') {
257 /* if the result is volatile then return result */
258 if (IS_OP_VOLATILE (IC_RESULT (cdp->diCode)))
259 *opp = IC_RESULT (cdp->diCode);
261 /* if this is a straight assignment and
262 left is a temp then prefer the temporary to the
264 if (!POINTER_SET (cdp->diCode) &&
265 IS_ITEMP (IC_RESULT (cdp->diCode)) &&
266 IS_TRUE_SYMOP (IC_RIGHT (cdp->diCode)))
267 *opp = IC_RESULT (cdp->diCode);
269 /* if straight assignement && and both
270 are temps then prefer the one that
271 will not need extra space to spil, also
272 take into consideration if right side
273 an induction variable
275 if (!POINTER_SET (cdp->diCode) &&
276 IS_ITEMP (IC_RESULT (cdp->diCode)) &&
277 IS_ITEMP (IC_RIGHT (cdp->diCode)) &&
278 !OP_SYMBOL (IC_RIGHT (cdp->diCode))->isind &&
279 ((!SPIL_LOC (IC_RIGHT (cdp->diCode)) &&
280 SPIL_LOC (IC_RESULT (cdp->diCode))) ||
281 (SPIL_LOC (IC_RESULT (cdp->diCode)) &&
282 SPIL_LOC (IC_RESULT (cdp->diCode)) ==
283 SPIL_LOC (IC_RIGHT (cdp->diCode)))))
284 *opp = IC_RESULT (cdp->diCode);
286 *opp = IC_RIGHT (cdp->diCode);
290 *opp = IC_RESULT (cdp->diCode);
293 /* if this is an assign to a temp. then check
294 if the right side is this then return this */
295 if (IS_TRUE_SYMOP (cop) &&
296 cdp->diCode->op == '=' &&
297 !POINTER_SET (cdp->diCode) &&
298 cop->key == IC_RIGHT (cdp->diCode)->key &&
299 !isGlobalInNearSpace (IC_RIGHT (cdp->diCode)) &&
300 IS_ITEMP (IC_RESULT (cdp->diCode)))
301 *opp = IC_RESULT (cdp->diCode);
304 (SPEC_USIGN(operandType (cop))==SPEC_USIGN(operandType (*opp))) &&
305 (SPEC_LONG(operandType (cop))==SPEC_LONG(operandType (*opp))))
308 if ((isGlobalInNearSpace (cop) &&
309 !isOperandLiteral (*opp)) ||
310 isOperandVolatile (*opp, FALSE)
317 if (cop->key == (*opp)->key)
323 if ((*opp)->isaddr != cop->isaddr && IS_ITEMP (cop))
325 *opp = operandFromOperand (*opp);
326 (*opp)->isaddr = cop->isaddr;
336 /*-----------------------------------------------------------------*/
337 /* findPointerSet - finds the right side of a pointer set op */
338 /*-----------------------------------------------------------------*/
339 DEFSETFUNC (findPointerSet)
342 V_ARG (operand *, op);
343 V_ARG (operand **, opp);
344 V_ARG (operand *, rop);
346 if (POINTER_SET (cdp->diCode) &&
347 IC_RESULT (cdp->diCode)->key == op->key &&
348 !isOperandVolatile (IC_RESULT (cdp->diCode), TRUE) &&
349 !isOperandVolatile (IC_RIGHT (cdp->diCode), TRUE) &&
350 getSize (operandType (IC_RIGHT (cdp->diCode))) ==
351 getSize (operandType (rop)))
353 *opp = IC_RIGHT (cdp->diCode);
360 /*-----------------------------------------------------------------*/
361 /* findPrevIc - cseBBlock support function will return the iCode */
362 /* which matches the current one */
363 /*-----------------------------------------------------------------*/
364 DEFSETFUNC (findPrevIc)
368 V_ARG (iCode **, icp);
370 /* if already found */
374 /* if the iCodes are the same */
375 if (isiCodeEqual (ic, cdp->diCode) &&
376 isOperandEqual (cdp->sym, IC_RESULT (cdp->diCode)))
382 /* if iCodes are not the same */
383 /* see the operands maybe interchanged */
384 if (ic->op == cdp->diCode->op &&
385 (ic->op == '+' || ic->op == '*') &&
386 isOperandEqual (IC_LEFT (ic), IC_RIGHT (cdp->diCode)) &&
387 isOperandEqual (IC_RIGHT (ic), IC_LEFT (cdp->diCode)))
396 /*-----------------------------------------------------------------*/
397 /* ifDefGlobal - if definition is global */
398 /*-----------------------------------------------------------------*/
399 DEFSETFUNC (ifDefGlobal)
403 return (isOperandGlobal (cdp->sym));
406 /*-----------------------------------------------------------------*/
407 /* ifAnyGetPointer - if get pointer icode */
408 /*-----------------------------------------------------------------*/
409 DEFSETFUNC (ifAnyGetPointer)
413 if (cdp->diCode && POINTER_GET (cdp->diCode))
418 /*-----------------------------------------------------------------*/
419 /* ifOperandsHave - if any of the operand are the same as this */
420 /*-----------------------------------------------------------------*/
421 DEFSETFUNC (ifOperandsHave)
424 V_ARG (operand *, op);
427 if (IC_LEFT (cdp->diCode) &&
428 IS_SYMOP (IC_LEFT (cdp->diCode)) &&
429 IC_LEFT (cdp->diCode)->key == op->key)
432 if (IC_RIGHT (cdp->diCode) &&
433 IS_SYMOP (IC_RIGHT (cdp->diCode)) &&
434 IC_RIGHT (cdp->diCode)->key == op->key)
437 /* or if any of the operands are volatile */
438 if (IC_LEFT (cdp->diCode) &&
439 IS_OP_VOLATILE (IC_LEFT (cdp->diCode)))
442 if (IC_RIGHT (cdp->diCode) &&
443 IS_OP_VOLATILE (IC_RIGHT (cdp->diCode)))
447 if (IC_RESULT (cdp->diCode) &&
448 IS_OP_VOLATILE (IC_RESULT (cdp->diCode)))
454 /*-----------------------------------------------------------------*/
455 /* ifDefSymIs - if a definition is found in the set */
456 /*-----------------------------------------------------------------*/
458 ifDefSymIs (set * cseSet, operand * sym)
463 if (!sym || !IS_SYMOP (sym))
465 for (sl = cseSet; sl; sl = sl->next)
468 if (loop->sym->key == sym->key)
475 /*-----------------------------------------------------------------*/
476 /* ifDefSymIsX - will return 1 if the symbols match */
477 /*-----------------------------------------------------------------*/
478 DEFSETFUNC (ifDefSymIsX)
481 V_ARG (operand *, op);
484 return cdp->sym->key == op->key;
486 return (isOperandEqual (cdp->sym, op));
491 /*-----------------------------------------------------------------*/
492 /* ifDiCodeIs - returns truw if diCode is same */
493 /*-----------------------------------------------------------------*/
495 ifDiCodeIs (set * cseSet, iCode * ic)
503 for (sl = cseSet; sl; sl = sl->next)
506 if (loop->diCode == ic)
513 /*-----------------------------------------------------------------*/
514 /* ifPointerGet - returns true if the icode is pointer get sym */
515 /*-----------------------------------------------------------------*/
516 DEFSETFUNC (ifPointerGet)
519 V_ARG (operand *, op);
520 iCode *dic = cdp->diCode;
521 operand *left = IC_LEFT (cdp->diCode);
523 if (POINTER_GET (dic) && left->key == op->key)
529 /*-----------------------------------------------------------------*/
530 /* ifPointerSet - returns true if the icode is pointer set sym */
531 /*-----------------------------------------------------------------*/
532 DEFSETFUNC (ifPointerSet)
535 V_ARG (operand *, op);
537 if (POINTER_SET (cdp->diCode) &&
538 IC_RESULT (cdp->diCode)->key == op->key)
544 /*-----------------------------------------------------------------*/
545 /* ifDiCodeIsX - will return 1 if the symbols match */
546 /*-----------------------------------------------------------------*/
547 DEFSETFUNC (ifDiCodeIsX)
552 return cdp->diCode == ic;
556 /*-----------------------------------------------------------------*/
557 /* algebraicOpts - does some algebraic optimizations */
558 /*-----------------------------------------------------------------*/
560 algebraicOpts (iCode * ic)
562 /* we don't deal with the following iCodes
573 /* if both operands present & ! IFX */
574 /* then if they are both literal we */
575 /* perform the operation right now */
576 if (IC_RESULT (ic) &&
579 IS_OP_LITERAL (IC_LEFT (ic)) &&
580 IS_OP_LITERAL (IC_RIGHT (ic)))
583 IC_RIGHT (ic) = operandOperation (IC_LEFT (ic),
586 operandType (IC_RESULT (ic)));
589 SET_RESULT_RIGHT (ic);
593 /* if not ifx & only one operand present */
594 if (IC_RESULT (ic) &&
596 IS_OP_LITERAL (IC_LEFT (ic)) &&
600 IC_RIGHT (ic) = operandOperation (IC_LEFT (ic),
603 operandType (IC_RESULT (ic)));
606 SET_RESULT_RIGHT (ic);
611 /* a special case : or in short a kludgy solution will think
612 about a better solution over a glass of wine someday */
613 if (ic->op == GET_VALUE_AT_ADDRESS)
616 if (IS_ITEMP (IC_RESULT (ic)) &&
617 IS_TRUE_SYMOP (IC_LEFT (ic)))
621 IC_RIGHT (ic) = operandFromOperand (IC_LEFT (ic));
622 IC_RIGHT (ic)->isaddr = 0;
624 IC_RESULT (ic) = operandFromOperand (IC_RESULT (ic));
625 IC_RESULT (ic)->isaddr = 0;
626 setOperandType (IC_RESULT (ic), operandType (IC_RIGHT (ic)));
630 if (IS_ITEMP (IC_LEFT (ic)) &&
631 IS_ITEMP (IC_RESULT (ic)) &&
632 /* !OP_SYMBOL(IC_RESULT(ic))->isreqv && */
633 /* !OP_SYMBOL(IC_LEFT(ic))->isreqv && */
634 !IC_LEFT (ic)->isaddr)
637 IC_RIGHT (ic) = operandFromOperand (IC_LEFT (ic));
638 IC_RIGHT (ic)->isaddr = 0;
639 IC_RESULT (ic) = operandFromOperand (IC_RESULT (ic));
640 IC_RESULT (ic)->isaddr = 0;
648 /* depending on the operation */
652 /* if adding the same thing change to left shift by 1 */
653 if (IC_LEFT (ic)->key == IC_RIGHT (ic)->key &&
654 !IS_FLOAT (operandType (IC_RESULT (ic))))
657 IC_RIGHT (ic) = operandFromLit (1);
660 /* if addition then check if one of them is a zero */
661 /* if yes turn it into assignmnt */
662 if (IS_OP_LITERAL (IC_LEFT (ic)) &&
663 operandLitValue (IC_LEFT (ic)) == 0.0)
668 SET_ISADDR (IC_RESULT (ic), 0);
669 SET_ISADDR (IC_RIGHT (ic), 0);
672 if (IS_OP_LITERAL (IC_RIGHT (ic)) &&
673 operandLitValue (IC_RIGHT (ic)) == 0.0)
677 IC_RIGHT (ic) = IC_LEFT (ic);
679 SET_ISADDR (IC_RIGHT (ic), 0);
680 SET_ISADDR (IC_RESULT (ic), 0);
685 /* if subtracting the the same thing then zero */
686 if (IC_LEFT (ic)->key == IC_RIGHT (ic)->key)
689 IC_RIGHT (ic) = operandFromLit (0);
691 IC_RESULT (ic) = operandFromOperand (IC_RESULT (ic));
692 IC_RESULT (ic)->isaddr = 0;
696 /* if subtraction then check if one of the operand */
697 /* is zero then depending on which operand change */
698 /* to assignment or unary minus */
699 if (IS_OP_LITERAL (IC_RIGHT (ic)) &&
700 operandLitValue (IC_RIGHT (ic)) == 0.0)
702 /* right size zero change to assignment */
704 IC_RIGHT (ic) = IC_LEFT (ic);
706 SET_ISADDR (IC_RIGHT (ic), 0);
707 SET_ISADDR (IC_RESULT (ic), 0);
710 if (IS_OP_LITERAL (IC_LEFT (ic)) &&
711 operandLitValue (IC_LEFT (ic)) == 0.0)
713 /* left zero turn into an unary minus */
715 IC_LEFT (ic) = IC_RIGHT (ic);
716 IC_RIGHT (ic) = NULL;
720 /* if multiplication then check if either of */
721 /* them is zero then the result is zero */
722 /* if either of them is one then result is */
725 if (IS_OP_LITERAL (IC_LEFT (ic)))
728 if (operandLitValue (IC_LEFT (ic)) == 0.0)
731 IC_RIGHT (ic) = IC_LEFT (ic);
733 SET_RESULT_RIGHT (ic);
736 if (operandLitValue (IC_LEFT (ic)) == 1.0)
740 SET_RESULT_RIGHT (ic);
745 if (IS_OP_LITERAL (IC_RIGHT (ic)))
748 if (operandLitValue (IC_RIGHT (ic)) == 0.0)
752 SET_RESULT_RIGHT (ic);
756 if (operandLitValue (IC_RIGHT (ic)) == 1.0)
759 IC_RIGHT (ic) = IC_LEFT (ic);
761 SET_RESULT_RIGHT (ic);
767 /* if division by self then 1 */
768 if (IC_LEFT (ic)->key == IC_RIGHT (ic)->key)
771 IC_RIGHT (ic) = operandFromLit (1);
773 IC_RESULT (ic) = operandFromOperand (IC_RESULT (ic));
774 IC_RESULT (ic)->isaddr = 0;
776 /* if this is a division then check if right */
777 /* is one then change it to an assignment */
778 if (IS_OP_LITERAL (IC_RIGHT (ic)) &&
779 operandLitValue (IC_RIGHT (ic)) == 1.0)
783 IC_RIGHT (ic) = IC_LEFT (ic);
785 SET_RESULT_RIGHT (ic);
789 /* if both are the same for an comparison operators */
793 if (isOperandEqual (IC_LEFT (ic), IC_RIGHT (ic)))
796 IC_RIGHT (ic) = operandFromLit (1);
798 SET_RESULT_RIGHT (ic);
804 if (isOperandEqual (IC_LEFT (ic), IC_RIGHT (ic)))
807 IC_RIGHT (ic) = operandFromLit (0);
809 SET_RESULT_RIGHT (ic);
814 sym_link *otype = operandType(IC_RIGHT(ic));
815 sym_link *ctype = operandType(IC_LEFT(ic));
816 /* if this is a cast of a literal value */
817 if (IS_OP_LITERAL (IC_RIGHT (ic)) &&
818 !(IS_GENPTR(ctype) && (IS_PTR(otype) && !IS_GENPTR(otype)))) {
821 operandFromValue (valCastLiteral (operandType (IC_LEFT (ic)),
822 operandLitValue (IC_RIGHT (ic))));
824 SET_ISADDR (IC_RESULT (ic), 0);
826 /* if casting to the same */
827 if (compareType (operandType (IC_RESULT (ic)),
828 operandType (IC_RIGHT (ic))) == 1) {
831 SET_ISADDR (IC_RESULT (ic), 0);
836 if (IS_OP_LITERAL (IC_LEFT (ic)))
840 (operandLitValue (IC_LEFT (ic)) == 0 ?
841 operandFromLit (1) : operandFromLit (0));
843 SET_ISADDR (IC_RESULT (ic), 0);
849 #define OTHERS_PARM(s) (s->_isparm && !s->ismyparm)
850 /*-----------------------------------------------------------------*/
851 /* updateSpillLocation - keeps track of register spill location */
852 /*-----------------------------------------------------------------*/
854 updateSpillLocation (iCode * ic, int induction)
859 if (POINTER_SET (ic))
865 /* for the form true_symbol := iTempNN */
866 if (ASSIGN_ITEMP_TO_SYM (ic) &&
867 !SPIL_LOC (IC_RIGHT (ic))) {
869 setype = getSpec (operandType (IC_RESULT (ic)));
871 if (!OP_SYMBOL(IC_RIGHT (ic))->noSpilLoc &&
872 !IS_VOLATILE (setype) &&
873 !IN_FARSPACE (SPEC_OCLS (setype)) &&
874 !OTHERS_PARM (OP_SYMBOL (IC_RESULT (ic))))
876 SPIL_LOC (IC_RIGHT (ic)) =
877 IC_RESULT (ic)->operand.symOperand;
880 if (ASSIGN_ITEMP_TO_ITEMP (ic)) {
882 if (!SPIL_LOC (IC_RIGHT (ic)) &&
883 !bitVectBitsInCommon (OP_DEFS (IC_RIGHT (ic)), OP_USES (IC_RESULT (ic))) &&
884 OP_SYMBOL (IC_RESULT (ic))->isreqv) {
886 setype = getSpec (operandType (IC_RESULT (ic)));
888 if (!OP_SYMBOL(IC_RIGHT (ic))->noSpilLoc &&
889 !IS_VOLATILE (setype) &&
890 !IN_FARSPACE (SPEC_OCLS (setype)) &&
891 !OTHERS_PARM (OP_SYMBOL (IC_RESULT (ic))))
893 SPIL_LOC (IC_RIGHT (ic)) =
894 SPIL_LOC (IC_RESULT (ic));
896 /* special case for inductions */
898 OP_SYMBOL(IC_RIGHT(ic))->isreqv &&
899 !OP_SYMBOL(IC_RESULT (ic))->noSpilLoc &&
900 !SPIL_LOC(IC_RESULT(ic))) {
901 SPIL_LOC (IC_RESULT (ic)) = SPIL_LOC (IC_RIGHT (ic));
905 /*-----------------------------------------------------------------*/
906 /* setUsesDef - sets the uses def bitvector for a given operand */
907 /*-----------------------------------------------------------------*/
909 setUsesDefs (operand * op, bitVect * bdefs,
910 bitVect * idefs, bitVect ** oud)
912 /* compute the definitions alive at this point */
913 bitVect *adefs = bitVectUnion (bdefs, idefs);
915 /* of these definitions find the ones that are */
916 /* for this operand */
917 adefs = bitVectIntersect (adefs, OP_DEFS (op));
919 /* these are the definitions that this operand can use */
920 op->usesDefs = adefs;
922 /* the out defs is an union */
923 *oud = bitVectUnion (*oud, adefs);
926 /*-----------------------------------------------------------------*/
927 /* unsetDefsAndUses - clear this operation for the operands */
928 /*-----------------------------------------------------------------*/
930 unsetDefsAndUses (iCode * ic)
932 if (ic->op == JUMPTABLE)
935 /* take away this definition from the def chain of the */
936 /* result & take away from use set of the operands */
939 /* turn off def set */
940 if (IS_SYMOP (IC_RESULT (ic)))
942 if (!POINTER_SET (ic))
943 bitVectUnSetBit (OP_DEFS (IC_RESULT (ic)), ic->key);
945 bitVectUnSetBit (OP_USES (IC_RESULT (ic)), ic->key);
947 /* turn off the useSet for the operands */
948 if (IS_SYMOP (IC_LEFT (ic)))
949 bitVectUnSetBit (OP_USES (IC_LEFT (ic)), ic->key);
951 if (IS_SYMOP (IC_RIGHT (ic)))
952 bitVectUnSetBit (OP_USES (IC_RIGHT (ic)), ic->key);
955 /* must be ifx turn off the use */ if (IS_SYMOP (IC_COND (ic)))
956 bitVectUnSetBit (OP_USES (IC_COND (ic)), ic->key);
959 /*-----------------------------------------------------------------*/
960 /* ifxOptimize - changes ifx conditions if it can */
961 /*-----------------------------------------------------------------*/
963 ifxOptimize (iCode * ic, set * cseSet,
965 eBBlock * ebb, int *change,
966 eBBlock ** ebbs, int count)
971 /* if the condition can be replaced */
975 applyToSetFTrue (cseSet, findCheaperOp, IC_COND (ic), &pdop);
983 /* if the conditional is a literal then */
984 if (IS_OP_LITERAL (IC_COND (ic)))
987 if ((operandLitValue (IC_COND (ic)) != 0.0) && IC_TRUE (ic))
990 /* change to a goto */
992 IC_LABEL (ic) = IC_TRUE (ic);
999 if (!operandLitValue (IC_COND (ic)) && IC_FALSE (ic))
1002 IC_LABEL (ic) = IC_FALSE (ic);
1008 /* then kill this if condition */
1009 remiCodeFromeBBlock (ebb, ic);
1013 /* now we need to recompute the control flow */
1014 /* since the control flow has changed */
1015 /* this is very expensive but it does not happen */
1016 /* too often, if it does happen then the user pays */
1018 computeControlFlow (ebbs, count, 1);
1019 if (!options.lessPedantic) {
1020 werror (W_CONTROL_FLOW, ic->filename, ic->lineno);
1025 /* if there is only one successor and that successor
1026 is the same one we are conditionally going to then
1027 we can remove this conditional statement */
1028 label = (IC_TRUE (ic) ? IC_TRUE (ic) : IC_FALSE (ic));
1029 if (elementsInSet (ebb->succList) == 1 &&
1030 isinSet (ebb->succList, eBBWithEntryLabel (ebbs, label, count)))
1033 remiCodeFromeBBlock (ebb, ic);
1034 computeControlFlow (ebbs, count, 1);
1035 if (!options.lessPedantic) {
1036 werror (W_CONTROL_FLOW, ic->filename, ic->lineno);
1042 /* if it remains an IFX the update the use Set */
1043 OP_USES (IC_COND (ic)) = bitVectSetBit (OP_USES (IC_COND (ic)), ic->key);
1044 setUsesDefs (IC_COND (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
1048 /*-----------------------------------------------------------------*/
1049 /* diCodeForSym - finds the definiting instruction for a symbol */
1050 /*-----------------------------------------------------------------*/
1051 DEFSETFUNC (diCodeForSym)
1054 V_ARG (operand *, sym);
1055 V_ARG (iCode **, dic);
1057 /* if already found */
1061 /* if not if this is the defining iCode */
1062 if (sym->key == cdp->key)
1071 /*-----------------------------------------------------------------*/
1072 /* constFold - does some constant folding */
1073 /*-----------------------------------------------------------------*/
1075 constFold (iCode * ic, set * cseSet)
1079 /* this routine will change
1085 /* deal with only + & - */
1086 if (ic->op != '+' &&
1090 /* this check is a hueristic to prevent live ranges
1091 from becoming too long */
1092 if (IS_PTR (operandType (IC_RESULT (ic))))
1095 /* check if operation with a literal */
1096 if (!IS_OP_LITERAL (IC_RIGHT (ic)))
1099 /* check if we can find a definition for the
1101 if (!(applyToSet (cseSet, diCodeForSym, IC_LEFT (ic), &dic)))
1104 /* check that this is also a +/- */
1105 if (dic->op != '+' && dic->op != '-')
1108 /* with a literal */
1109 if (!IS_OP_LITERAL (IC_RIGHT (dic)))
1112 /* find the definition of the left operand
1113 of dic.then check if this defined with a
1114 get_pointer return 0 if the pointer size is
1115 less than 2 (MCS51 specific) */
1116 if (!(applyToSet (cseSet, diCodeForSym, IC_LEFT (dic), &ldic)))
1119 if (POINTER_GET (ldic) && getSize (operandType (IC_LEFT (ldic))) <= 1)
1122 /* it is if the operations are the same */
1123 /* the literal parts need to be added */
1124 IC_LEFT (ic) = operandFromOperand (IC_LEFT (dic));
1125 if (ic->op == dic->op)
1126 IC_RIGHT (ic) = operandFromLit (operandLitValue (IC_RIGHT (ic)) +
1127 operandLitValue (IC_RIGHT (dic)));
1129 IC_RIGHT (ic) = operandFromLit (operandLitValue (IC_RIGHT (ic)) -
1130 operandLitValue (IC_RIGHT (dic)));
1132 if (IS_ITEMP (IC_RESULT (ic)))
1134 SPIL_LOC (IC_RESULT (ic)) = NULL;
1135 OP_SYMBOL(IC_RESULT (ic))->noSpilLoc = 1;
1142 /*-----------------------------------------------------------------*/
1143 /* deleteGetPointers - called when a pointer is passed as parm */
1144 /* will delete from cseSet all get pointers computed from this */
1145 /* pointer. A simple ifOperandsHave is not good enough here */
1146 /*-----------------------------------------------------------------*/
1148 deleteGetPointers (set ** cseSet, set ** pss, operand * op, eBBlock * ebb)
1150 set *compItems = NULL;
1155 if (!*cseSet && !*pss)
1158 /* first find all items computed from this operand .
1159 This done fairly simply go thru the list and find
1160 those that are computed by arthimetic with this
1162 for (cdp = setFirstItem (*cseSet); cdp; cdp = setNextItem (*cseSet))
1164 if (IS_ARITHMETIC_OP (cdp->diCode))
1166 if (isOperandEqual (IC_LEFT (cdp->diCode), op) ||
1167 isOperandEqual (IC_RIGHT (cdp->diCode), op))
1169 /* save it in our list of items */
1170 addSet (&compItems, IC_RESULT (cdp->diCode));
1172 /* also check for those computed from our computed
1173 list . This will take care of situations like
1174 iTemp1 = iTemp0 + 8;
1175 iTemp2 = iTemp1 + 8; */
1176 if (isinSetWith (compItems, (void*)IC_LEFT (cdp->diCode),
1177 (insetwithFunc)isOperandEqual) ||
1178 isinSetWith (compItems, (void*)IC_RIGHT (cdp->diCode),
1179 (insetwithFunc)isOperandEqual))
1181 addSet (&compItems, IC_RESULT (cdp->diCode));
1186 /* now delete all pointer gets with this op */
1187 deleteItemIf (cseSet, ifPointerGet, op);
1188 deleteItemIf (pss, ifPointerSet, op);
1190 /* set the bit vector used by dataFlow computation later */
1191 ebb->ptrsSet = bitVectSetBit (ebb->ptrsSet, op->key);
1192 /* now for the computed items */
1193 for (cop = setFirstItem (compItems); cop; cop = setNextItem (compItems))
1195 ebb->ptrsSet = bitVectSetBit (ebb->ptrsSet, cop->key);
1196 deleteItemIf (cseSet, ifPointerGet, cop);
1197 deleteItemIf (pss, ifPointerSet, cop);
1201 /*-----------------------------------------------------------------*/
1202 /* delGetPointerSucc - delete get pointer from inExprs of succ with */
1203 /* dfnum > supplied */
1204 /*-----------------------------------------------------------------*/
1205 DEFSETFUNC (delGetPointerSucc)
1207 eBBlock *ebp = item;
1208 V_ARG (operand *, op);
1215 if (ebp->dfnum > dfnum)
1217 deleteItemIf (&ebp->inExprs, ifPointerGet, op);
1220 return applyToSet (ebp->succList, delGetPointerSucc, op, dfnum);
1223 /*-----------------------------------------------------------------*/
1224 /* fixUpTypes - KLUGE HACK fixup a lowering problem */
1225 /*-----------------------------------------------------------------*/
1227 fixUpTypes (iCode * ic)
1229 sym_link *t1 = operandType (IC_LEFT (ic)), *t2;
1231 /* if (TARGET_IS_DS390) */
1232 if (options.model == MODEL_FLAT24)
1238 /* for pointer_gets if the types of result & left r the
1239 same then change it type of result to next */
1241 compareType (t2 = operandType (IC_RESULT (ic)), t1) == 1)
1243 setOperandType (IC_RESULT (ic), t2->next);
1247 /*-----------------------------------------------------------------*/
1248 /* cseBBlock - common subexpression elimination for basic blocks */
1249 /* this is the hackiest kludgiest routine in the whole */
1250 /* system. also the most important, since almost all */
1251 /* data flow related information is computed by it */
1252 /*-----------------------------------------------------------------*/
1254 cseBBlock (eBBlock * ebb, int computeOnly,
1255 eBBlock ** ebbs, int count)
1261 set *ptrSetSet = NULL;
1263 /* if this block is not reachable */
1267 /* set of common subexpressions */
1268 cseSet = setFromSet (ebb->inExprs);
1270 /* these will be computed by this routine */
1271 setToNull ((void **) &ebb->outDefs);
1272 setToNull ((void **) &ebb->defSet);
1273 setToNull ((void **) &ebb->usesDefs);
1274 setToNull ((void **) &ebb->ptrsSet);
1275 setToNull ((void **) &ebb->addrOf);
1276 setToNull ((void **) &ebb->ldefs);
1278 ebb->outDefs = bitVectCopy (ebb->inDefs);
1279 bitVectDefault = iCodeKey;
1280 ebb->defSet = newBitVect (iCodeKey);
1281 ebb->usesDefs = newBitVect (iCodeKey);
1283 /* for all the instructions in this block do */
1284 for (ic = ebb->sch; ic; ic = ic->next)
1294 /* if this is an assignment from true symbol
1295 to a temp then do pointer post inc/dec optimzation */
1296 if (ic->op == '=' && !POINTER_SET (ic) &&
1297 IS_PTR (operandType (IC_RESULT (ic))))
1299 ptrPostIncDecOpt (ic);
1302 /* clear the def & use chains for the operands involved */
1303 /* in this operation . since it can change due to opts */
1304 unsetDefsAndUses (ic);
1306 if (ic->op == PCALL || ic->op == CALL || ic->op == RECEIVE)
1308 /* add to defSet of the symbol */
1309 OP_DEFS (IC_RESULT (ic)) =
1310 bitVectSetBit (OP_DEFS (IC_RESULT (ic)), ic->key);
1311 /* add to the definition set of this block */
1312 ebb->defSet = bitVectSetBit (ebb->defSet, ic->key);
1313 ebb->ldefs = bitVectSetBit (ebb->ldefs, ic->key);
1314 ebb->outDefs = bitVectCplAnd (ebb->outDefs, OP_DEFS (IC_RESULT (ic)));
1315 setUsesDefs (IC_RESULT (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
1316 /* delete global variables from the cseSet
1317 since they can be modified by the function call */
1318 deleteItemIf (&cseSet, ifDefGlobal);
1319 /* delete all getpointer iCodes from cseSet, this should
1320 be done only for global arrays & pointers but at this
1321 point we don't know if globals, so to be safe do all */
1322 deleteItemIf (&cseSet, ifAnyGetPointer);
1325 /* for pcall & ipush we need to add to the useSet */
1326 if ((ic->op == PCALL ||
1330 IS_SYMOP (IC_LEFT (ic)))
1333 /* check if they can be replaced */
1337 applyToSetFTrue (cseSet, findCheaperOp, IC_LEFT (ic), &pdop);
1339 IC_LEFT (ic) = pdop;
1341 /* the lookup could have changed it */
1342 if (IS_SYMOP (IC_LEFT (ic)))
1344 OP_USES (IC_LEFT (ic)) =
1345 bitVectSetBit (OP_USES (IC_LEFT (ic)), ic->key);
1346 setUsesDefs (IC_LEFT (ic), ebb->defSet,
1347 ebb->outDefs, &ebb->usesDefs);
1351 /* if we a sending a pointer as a parameter
1352 then kill all cse since the pointed to item
1353 might be changed in the function being called */
1354 if ((ic->op == IPUSH || ic->op == SEND) &&
1355 IS_PTR (operandType (IC_LEFT (ic))))
1357 deleteGetPointers (&cseSet, &ptrSetSet, IC_LEFT (ic), ebb);
1358 ebb->ptrsSet = bitVectSetBit (ebb->ptrsSet, IC_LEFT (ic)->key);
1359 for (i = 0; i < count; ebbs[i++]->visited = 0);
1360 applyToSet (ebb->succList, delGetPointerSucc,
1361 IC_LEFT (ic), ebb->dfnum);
1366 /* if jumptable then mark the usage */
1367 if (ic->op == JUMPTABLE)
1369 OP_USES (IC_JTCOND (ic)) =
1370 bitVectSetBit (OP_USES (IC_JTCOND (ic)), ic->key);
1371 setUsesDefs (IC_JTCOND (ic), ebb->defSet,
1372 ebb->outDefs, &ebb->usesDefs);
1379 /* do some algebraic optimizations if possible */
1381 while (constFold (ic, cseSet));
1384 if (POINTER_GET (ic) && !IS_PTR (operandType (IC_LEFT (ic))))
1386 setOperandType (IC_LEFT (ic),
1387 aggrToPtr (operandType (IC_LEFT (ic)), FALSE));
1391 if (POINTER_SET (ic) && !IS_PTR (operandType (IC_RESULT (ic))))
1393 setOperandType (IC_RESULT (ic),
1394 aggrToPtr (operandType (IC_RESULT (ic)), FALSE));
1397 /* if this is a condition statment then */
1398 /* check if the condition can be replaced */
1401 ifxOptimize (ic, cseSet, computeOnly,
1407 /* if the assignment & result is a temp */
1408 /* see if we can replace it */
1412 /* update the spill location for this */
1413 updateSpillLocation (ic,0);
1415 if (POINTER_SET (ic) &&
1416 !(IS_BITFIELD (OP_SYMBOL (IC_RESULT (ic))->etype)))
1419 applyToSetFTrue (cseSet, findCheaperOp, IC_RESULT (ic), &pdop);
1420 if (pdop && IS_ITEMP (pdop) && !computeOnly)
1421 IC_RESULT (ic) = pdop;
1425 /* do the operand lookup i.e. for both the */
1426 /* right & left operand : check the cseSet */
1427 /* to see if they have been replaced if yes */
1428 /* then replace them with those from cseSet */
1430 /* and left is a symbol */
1431 if (IS_SYMOP (IC_LEFT (ic)) &&
1432 !computeOnly && ic->op != ADDRESS_OF)
1436 applyToSetFTrue (cseSet, findCheaperOp, IC_LEFT (ic), &pdop);
1439 if (POINTER_GET (ic))
1441 if (IS_ITEMP (pdop) || IS_OP_LITERAL (pdop))
1443 IC_LEFT (ic) = pdop;
1446 /* check if there is a pointer set
1447 for the same pointer visible if yes
1448 then change this into an assignment */
1450 if (applyToSetFTrue (cseSet, findPointerSet, IC_LEFT (ic), &pdop, IC_RESULT (ic)) &&
1451 !bitVectBitValue (ebb->ptrsSet, pdop->key))
1454 IC_LEFT (ic) = NULL;
1455 IC_RIGHT (ic) = pdop;
1456 SET_ISADDR (IC_RESULT (ic), 0);
1462 IC_LEFT (ic) = pdop;
1469 if (IS_SYMOP (IC_RIGHT (ic)) && !computeOnly)
1473 applyToSetFTrue (cseSet, findCheaperOp, IC_RIGHT (ic), &pdop);
1477 IC_RIGHT (ic) = pdop;
1482 /* if left or right changed then do algebraic */
1486 while (constFold (ic, cseSet));
1489 /* if after all this it becomes a assignment to self
1490 then delete it and continue */
1491 if (ASSIGNMENT_TO_SELF (ic))
1493 remiCodeFromeBBlock (ebb, ic);
1497 /* now we will check to see if the entire */
1498 /* operation has been performed before */
1499 /* and is available */
1500 /* don't do assignments they will be killed */
1501 /* by dead code elimination if required do */
1502 /* it only if result is a temporary */
1504 if (!(POINTER_GET (ic) &&
1505 (IS_BITFIELD (OP_SYMBOL (IC_RESULT (ic))->etype) ||
1506 isOperandVolatile (IC_LEFT (ic), TRUE) ||
1507 bitVectBitValue (ebb->ndompset, IC_LEFT (ic)->key))) &&
1509 IS_ITEMP (IC_RESULT (ic)) &&
1512 applyToSet (cseSet, findPrevIc, ic, &pdic);
1513 if (pdic && compareType (operandType (IC_RESULT (pdic)),
1514 operandType (IC_RESULT (ic))) != 1)
1518 /* if found then eliminate this and add to */
1519 /* to cseSet an element containing result */
1520 /* of this with previous opcode */
1524 if (IS_ITEMP (IC_RESULT (ic)))
1527 /* replace in the remaining of this block */
1528 replaceAllSymBySym (ic->next, IC_RESULT (ic), IC_RESULT (pdic), &ebb->ndompset);
1529 /* remove this iCode from inexpressions of all
1530 its successors, it cannot be in the in expressions
1531 of any of the predecessors */
1532 for (i = 0; i < count; ebbs[i++]->visited = 0);
1533 applyToSet (ebb->succList, removeFromInExprs, ic, IC_RESULT (ic),
1534 IC_RESULT (pdic), ebb);
1536 /* if this was moved from another block */
1537 /* then replace in those blocks too */
1541 for (owner = setFirstItem (ic->movedFrom); owner;
1542 owner = setNextItem (ic->movedFrom))
1543 replaceAllSymBySym (owner->sch, IC_RESULT (ic), IC_RESULT (pdic), &owner->ndompset);
1545 pdic->movedFrom = unionSets (pdic->movedFrom, ic->movedFrom, THROW_NONE);
1548 addSetHead (&cseSet, newCseDef (IC_RESULT (ic), pdic));
1551 /* eliminate this */
1552 remiCodeFromeBBlock (ebb, ic);
1557 if (IS_ITEMP (IC_RESULT (ic)))
1564 /* just add this as a previous expression except in */
1565 /* case of a pointer access in which case this is a */
1566 /* usage not a definition */
1567 if (!(POINTER_SET (ic)) && IC_RESULT (ic))
1569 deleteItemIf (&cseSet, ifDefSymIsX, IC_RESULT (ic));
1570 addSetHead (&cseSet, newCseDef (IC_RESULT (ic), ic));
1576 /* if assignment to a parameter which is not
1577 mine and type is a pointer then delete
1578 pointerGets to take care of aliasing */
1579 if (ASSIGNMENT (ic) &&
1580 OTHERS_PARM (OP_SYMBOL (IC_RESULT (ic))) &&
1581 IS_PTR (operandType (IC_RESULT (ic))))
1583 deleteGetPointers (&cseSet, &ptrSetSet, IC_RIGHT (ic), ebb);
1584 for (i = 0; i < count; ebbs[i++]->visited = 0);
1585 applyToSet (ebb->succList, delGetPointerSucc, IC_RIGHT (ic), ebb->dfnum);
1586 ebb->ptrsSet = bitVectSetBit (ebb->ptrsSet, IC_RIGHT (ic)->key);
1589 /* if this is a pointerget then see if we can replace
1590 this with a previously assigned pointer value */
1591 if (POINTER_GET (ic) &&
1592 !(IS_BITFIELD (OP_SYMBOL (IC_RESULT (ic))->etype) ||
1593 isOperandVolatile (IC_LEFT (ic), TRUE)))
1596 applyToSet (ptrSetSet, findPointerSet, IC_LEFT (ic), &pdop, IC_RESULT (ic));
1597 /* if we find it then locally replace all
1598 references to the result with what we assigned */
1601 replaceAllSymBySym (ic->next, IC_RESULT (ic), pdop, &ebb->ndompset);
1605 /* delete from the cseSet anything that has */
1606 /* operands matching the result of this */
1607 /* except in case of pointer access */
1608 if (!(POINTER_SET (ic)) && IC_RESULT (ic))
1610 deleteItemIf (&cseSet, ifOperandsHave, IC_RESULT (ic));
1611 /* delete any previous definitions */
1612 ebb->defSet = bitVectCplAnd (ebb->defSet, OP_DEFS (IC_RESULT (ic)));
1616 /* add the left & right to the defUse set */
1617 if (IC_LEFT (ic) && IS_SYMOP (IC_LEFT (ic)))
1619 OP_USES (IC_LEFT (ic)) =
1620 bitVectSetBit (OP_USES (IC_LEFT (ic)), ic->key);
1621 setUsesDefs (IC_LEFT (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
1625 if (IC_RIGHT (ic) && IS_SYMOP (IC_RIGHT (ic)))
1627 OP_USES (IC_RIGHT (ic)) =
1628 bitVectSetBit (OP_USES (IC_RIGHT (ic)), ic->key);
1629 setUsesDefs (IC_RIGHT (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
1633 /* for the result it is special case, put the result */
1634 /* in the defuseSet if it a pointer or array access */
1635 if (POINTER_SET (defic))
1637 OP_USES (IC_RESULT (ic)) =
1638 bitVectSetBit (OP_USES (IC_RESULT (ic)), ic->key);
1639 setUsesDefs (IC_RESULT (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
1640 deleteItemIf (&cseSet, ifPointerGet, IC_RESULT (ic));
1641 ebb->ptrsSet = bitVectSetBit (ebb->ptrsSet, IC_RESULT (ic)->key);
1642 /* delete from inexpressions of all successors which
1643 have dfNum > than this block */
1644 for (i = 0; i < count; ebbs[i++]->visited = 0);
1645 applyToSet (ebb->succList, delGetPointerSucc, IC_RESULT (ic), ebb->dfnum);
1647 /* delete from cseSet all other pointer sets
1649 deleteItemIf (&ptrSetSet, ifPointerSet, IC_RESULT (ic));
1650 /* add to the local pointerset set */
1651 addSetHead (&ptrSetSet, newCseDef (IC_RESULT (ic), ic));
1654 /* add the result to defintion set */ if (IC_RESULT (ic))
1656 OP_DEFS (IC_RESULT (ic)) =
1657 bitVectSetBit (OP_DEFS (IC_RESULT (ic)), ic->key);
1658 ebb->defSet = bitVectSetBit (ebb->defSet, ic->key);
1659 ebb->outDefs = bitVectCplAnd (ebb->outDefs, OP_DEFS (IC_RESULT (ic)));
1660 ebb->ldefs = bitVectSetBit (ebb->ldefs, ic->key);
1664 /* if this is an addressof instruction then */
1665 /* put the symbol in the address of list & */
1666 /* delete it from the cseSet */
1667 if (defic->op == ADDRESS_OF)
1669 addSetHead (&ebb->addrOf, IC_LEFT (ic));
1670 deleteItemIf (&cseSet, ifDefSymIsX, IC_LEFT (ic));
1674 setToNull ((void **) &ebb->outExprs);
1675 ebb->outExprs = cseSet;
1676 ebb->outDefs = bitVectUnion (ebb->outDefs, ebb->defSet);
1677 ebb->ptrsSet = bitVectUnion (ebb->ptrsSet, ebb->inPtrsSet);
1681 /*-----------------------------------------------------------------*/
1682 /* cseAllBlocks - will sequentially go thru & do cse for all blocks */
1683 /*-----------------------------------------------------------------*/
1685 cseAllBlocks (eBBlock ** ebbs, int count)
1690 /* if optimization turned off */
1692 for (i = 0; i < count; i++)
1693 change += cseBBlock (ebbs[i], FALSE, ebbs, count);