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_alloc (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);
243 V_ARG (int, checkSign);
245 /* if we have already found it */
249 /* not found it yet check if this is the one */
250 /* and this is not the defining one */
251 if (cop->key == cdp->key)
254 /* do a special check this will help in */
255 /* constant propagation & dead code elim */
256 /* for assignments only */
257 if (cdp->diCode->op == '=') {
258 /* if the result is volatile then return result */
259 if (IS_OP_VOLATILE (IC_RESULT (cdp->diCode)))
260 *opp = IC_RESULT (cdp->diCode);
262 /* if this is a straight assignment and
263 left is a temp then prefer the temporary to the
265 if (!POINTER_SET (cdp->diCode) &&
266 IS_ITEMP (IC_RESULT (cdp->diCode)) &&
267 IS_TRUE_SYMOP (IC_RIGHT (cdp->diCode)))
268 *opp = IC_RESULT (cdp->diCode);
270 /* if straight assignement && and both
271 are temps then prefer the one that
272 will not need extra space to spil, also
273 take into consideration if right side
274 an induction variable
276 if (!POINTER_SET (cdp->diCode) &&
277 IS_ITEMP (IC_RESULT (cdp->diCode)) &&
278 IS_ITEMP (IC_RIGHT (cdp->diCode)) &&
279 !OP_SYMBOL (IC_RIGHT (cdp->diCode))->isind &&
280 !OP_SYMBOL(IC_RIGHT (cdp->diCode))->isreqv &&
281 ((!SPIL_LOC (IC_RIGHT (cdp->diCode)) &&
282 SPIL_LOC (IC_RESULT (cdp->diCode))) ||
283 (SPIL_LOC (IC_RESULT (cdp->diCode)) &&
284 SPIL_LOC (IC_RESULT (cdp->diCode)) ==
285 SPIL_LOC (IC_RIGHT (cdp->diCode)))))
286 *opp = IC_RESULT (cdp->diCode);
288 *opp = IC_RIGHT (cdp->diCode);
292 *opp = IC_RESULT (cdp->diCode);
295 /* if this is an assign to a temp. then check
296 if the right side is this then return this */
297 if (IS_TRUE_SYMOP (cop) &&
298 cdp->diCode->op == '=' &&
299 !POINTER_SET (cdp->diCode) &&
300 cop->key == IC_RIGHT (cdp->diCode)->key &&
301 !isGlobalInNearSpace (IC_RIGHT (cdp->diCode)) &&
302 IS_ITEMP (IC_RESULT (cdp->diCode)))
303 *opp = IC_RESULT (cdp->diCode);
306 (isOperandLiteral(*opp) || !checkSign ||
308 (SPEC_USIGN(operandType (cop))==SPEC_USIGN(operandType (*opp)) &&
309 (SPEC_LONG(operandType (cop))==SPEC_LONG(operandType (*opp)))))))
312 if ((isGlobalInNearSpace (cop) &&
313 !isOperandLiteral (*opp)) ||
314 isOperandVolatile (*opp, FALSE)
321 if (cop->key == (*opp)->key)
327 if ((*opp)->isaddr != cop->isaddr && IS_ITEMP (cop))
329 *opp = operandFromOperand (*opp);
330 (*opp)->isaddr = cop->isaddr;
340 /*-----------------------------------------------------------------*/
341 /* findPointerSet - finds the right side of a pointer set op */
342 /*-----------------------------------------------------------------*/
343 DEFSETFUNC (findPointerSet)
346 V_ARG (operand *, op);
347 V_ARG (operand **, opp);
348 V_ARG (operand *, rop);
350 if (POINTER_SET (cdp->diCode) &&
351 IC_RESULT (cdp->diCode)->key == op->key &&
352 !isOperandVolatile (IC_RESULT (cdp->diCode), TRUE) &&
353 !isOperandVolatile (IC_RIGHT (cdp->diCode), TRUE) &&
354 getSize (operandType (IC_RIGHT (cdp->diCode))) ==
355 getSize (operandType (rop)))
357 *opp = IC_RIGHT (cdp->diCode);
364 /*-----------------------------------------------------------------*/
365 /* findPrevIc - cseBBlock support function will return the iCode */
366 /* which matches the current one */
367 /*-----------------------------------------------------------------*/
368 DEFSETFUNC (findPrevIc)
372 V_ARG (iCode **, icp);
374 /* if already found */
378 /* if the iCodes are the same */
379 if (isiCodeEqual (ic, cdp->diCode) &&
380 isOperandEqual (cdp->sym, IC_RESULT (cdp->diCode)))
386 /* if iCodes are not the same */
387 /* see the operands maybe interchanged */
388 if (ic->op == cdp->diCode->op &&
389 (ic->op == '+' || ic->op == '*') &&
390 isOperandEqual (IC_LEFT (ic), IC_RIGHT (cdp->diCode)) &&
391 isOperandEqual (IC_RIGHT (ic), IC_LEFT (cdp->diCode)))
400 /*-------------------------------------------------------------------*/
401 /* ifAssignedFromGlobal - if definition is an assignment from global */
402 /*-------------------------------------------------------------------*/
403 DEFSETFUNC (ifAssignedFromGlobal)
406 iCode *dic=cdp->diCode;
408 if (dic->op=='=' && isOperandGlobal(IC_RIGHT(dic))) {
414 /*-----------------------------------------------------------------*/
415 /* ifDefGlobal - if definition is global */
416 /*-----------------------------------------------------------------*/
417 DEFSETFUNC (ifDefGlobal)
421 return (isOperandGlobal (cdp->sym));
424 /*-----------------------------------------------------------------*/
425 /* ifAnyGetPointer - if get pointer icode */
426 /*-----------------------------------------------------------------*/
427 DEFSETFUNC (ifAnyGetPointer)
431 if (cdp->diCode && POINTER_GET (cdp->diCode))
436 /*-----------------------------------------------------------------*/
437 /* ifOperandsHave - if any of the operand are the same as this */
438 /*-----------------------------------------------------------------*/
439 DEFSETFUNC (ifOperandsHave)
442 V_ARG (operand *, op);
445 if (IC_LEFT (cdp->diCode) &&
446 IS_SYMOP (IC_LEFT (cdp->diCode)) &&
447 IC_LEFT (cdp->diCode)->key == op->key)
450 if (IC_RIGHT (cdp->diCode) &&
451 IS_SYMOP (IC_RIGHT (cdp->diCode)) &&
452 IC_RIGHT (cdp->diCode)->key == op->key)
455 /* or if any of the operands are volatile */
456 if (IC_LEFT (cdp->diCode) &&
457 IS_OP_VOLATILE (IC_LEFT (cdp->diCode)))
460 if (IC_RIGHT (cdp->diCode) &&
461 IS_OP_VOLATILE (IC_RIGHT (cdp->diCode)))
465 if (IC_RESULT (cdp->diCode) &&
466 IS_OP_VOLATILE (IC_RESULT (cdp->diCode)))
472 /*-----------------------------------------------------------------*/
473 /* ifDefSymIs - if a definition is found in the set */
474 /*-----------------------------------------------------------------*/
476 ifDefSymIs (set * cseSet, operand * sym)
481 if (!sym || !IS_SYMOP (sym))
483 for (sl = cseSet; sl; sl = sl->next)
486 if (loop->sym->key == sym->key)
493 /*-----------------------------------------------------------------*/
494 /* ifDefSymIsX - will return 1 if the symbols match */
495 /*-----------------------------------------------------------------*/
496 DEFSETFUNC (ifDefSymIsX)
499 V_ARG (operand *, op);
502 return cdp->sym->key == op->key;
504 return (isOperandEqual (cdp->sym, op));
509 /*-----------------------------------------------------------------*/
510 /* ifDiCodeIs - returns truw if diCode is same */
511 /*-----------------------------------------------------------------*/
513 ifDiCodeIs (set * cseSet, iCode * ic)
521 for (sl = cseSet; sl; sl = sl->next)
524 if (loop->diCode == ic)
531 /*-----------------------------------------------------------------*/
532 /* ifPointerGet - returns true if the icode is pointer get sym */
533 /*-----------------------------------------------------------------*/
534 DEFSETFUNC (ifPointerGet)
537 V_ARG (operand *, op);
538 iCode *dic = cdp->diCode;
539 operand *left = IC_LEFT (cdp->diCode);
541 if (POINTER_GET (dic) && left->key == op->key)
547 /*-----------------------------------------------------------------*/
548 /* ifPointerSet - returns true if the icode is pointer set sym */
549 /*-----------------------------------------------------------------*/
550 DEFSETFUNC (ifPointerSet)
553 V_ARG (operand *, op);
555 if (POINTER_SET (cdp->diCode) &&
556 IC_RESULT (cdp->diCode)->key == op->key)
562 /*-----------------------------------------------------------------*/
563 /* ifDiCodeIsX - will return 1 if the symbols match */
564 /*-----------------------------------------------------------------*/
565 DEFSETFUNC (ifDiCodeIsX)
570 return cdp->diCode == ic;
574 /*-----------------------------------------------------------------*/
575 /* algebraicOpts - does some algebraic optimizations */
576 /*-----------------------------------------------------------------*/
578 algebraicOpts (iCode * ic)
580 /* we don't deal with the following iCodes
591 /* if both operands present & ! IFX */
592 /* then if they are both literal we */
593 /* perform the operation right now */
594 if (IC_RESULT (ic) &&
597 IS_OP_LITERAL (IC_LEFT (ic)) &&
598 IS_OP_LITERAL (IC_RIGHT (ic)))
601 IC_RIGHT (ic) = operandOperation (IC_LEFT (ic),
604 operandType (IC_RESULT (ic)));
607 SET_RESULT_RIGHT (ic);
611 /* if not ifx & only one operand present */
612 if (IC_RESULT (ic) &&
614 IS_OP_LITERAL (IC_LEFT (ic)) &&
618 IC_RIGHT (ic) = operandOperation (IC_LEFT (ic),
621 operandType (IC_RESULT (ic)));
624 SET_RESULT_RIGHT (ic);
629 /* a special case : or in short a kludgy solution will think
630 about a better solution over a glass of wine someday */
631 if (ic->op == GET_VALUE_AT_ADDRESS)
634 if (IS_ITEMP (IC_RESULT (ic)) &&
635 IS_TRUE_SYMOP (IC_LEFT (ic)))
639 IC_RIGHT (ic) = operandFromOperand (IC_LEFT (ic));
640 IC_RIGHT (ic)->isaddr = 0;
642 IC_RESULT (ic) = operandFromOperand (IC_RESULT (ic));
643 IC_RESULT (ic)->isaddr = 0;
644 setOperandType (IC_RESULT (ic), operandType (IC_RIGHT (ic)));
648 if (IS_ITEMP (IC_LEFT (ic)) &&
649 IS_ITEMP (IC_RESULT (ic)) &&
650 /* !OP_SYMBOL(IC_RESULT(ic))->isreqv && */
651 /* !OP_SYMBOL(IC_LEFT(ic))->isreqv && */
652 !IC_LEFT (ic)->isaddr)
655 IC_RIGHT (ic) = operandFromOperand (IC_LEFT (ic));
656 IC_RIGHT (ic)->isaddr = 0;
657 IC_RESULT (ic) = operandFromOperand (IC_RESULT (ic));
658 IC_RESULT (ic)->isaddr = 0;
666 /* depending on the operation */
670 /* if adding the same thing change to left shift by 1 */
671 if (IC_LEFT (ic)->key == IC_RIGHT (ic)->key &&
672 !IS_FLOAT (operandType (IC_RESULT (ic))))
675 IC_RIGHT (ic) = operandFromLit (1);
678 /* if addition then check if one of them is a zero */
679 /* if yes turn it into assignmnt */
680 if (IS_OP_LITERAL (IC_LEFT (ic)) &&
681 operandLitValue (IC_LEFT (ic)) == 0.0)
686 SET_ISADDR (IC_RESULT (ic), 0);
687 SET_ISADDR (IC_RIGHT (ic), 0);
690 if (IS_OP_LITERAL (IC_RIGHT (ic)) &&
691 operandLitValue (IC_RIGHT (ic)) == 0.0)
695 IC_RIGHT (ic) = IC_LEFT (ic);
697 SET_ISADDR (IC_RIGHT (ic), 0);
698 SET_ISADDR (IC_RESULT (ic), 0);
703 /* if subtracting the the same thing then zero */
704 if (IC_LEFT (ic)->key == IC_RIGHT (ic)->key)
707 IC_RIGHT (ic) = operandFromLit (0);
709 IC_RESULT (ic) = operandFromOperand (IC_RESULT (ic));
710 IC_RESULT (ic)->isaddr = 0;
714 /* if subtraction then check if one of the operand */
715 /* is zero then depending on which operand change */
716 /* to assignment or unary minus */
717 if (IS_OP_LITERAL (IC_RIGHT (ic)) &&
718 operandLitValue (IC_RIGHT (ic)) == 0.0)
720 /* right size zero change to assignment */
722 IC_RIGHT (ic) = IC_LEFT (ic);
724 SET_ISADDR (IC_RIGHT (ic), 0);
725 SET_ISADDR (IC_RESULT (ic), 0);
728 if (IS_OP_LITERAL (IC_LEFT (ic)) &&
729 operandLitValue (IC_LEFT (ic)) == 0.0)
731 /* left zero turn into an unary minus */
733 IC_LEFT (ic) = IC_RIGHT (ic);
734 IC_RIGHT (ic) = NULL;
738 /* if multiplication then check if either of */
739 /* them is zero then the result is zero */
740 /* if either of them is one then result is */
743 if (IS_OP_LITERAL (IC_LEFT (ic)))
746 if (operandLitValue (IC_LEFT (ic)) == 0.0)
749 IC_RIGHT (ic) = IC_LEFT (ic);
751 SET_RESULT_RIGHT (ic);
754 if (operandLitValue (IC_LEFT (ic)) == 1.0)
758 SET_RESULT_RIGHT (ic);
763 if (IS_OP_LITERAL (IC_RIGHT (ic)))
766 if (operandLitValue (IC_RIGHT (ic)) == 0.0)
770 SET_RESULT_RIGHT (ic);
774 if (operandLitValue (IC_RIGHT (ic)) == 1.0)
777 IC_RIGHT (ic) = IC_LEFT (ic);
779 SET_RESULT_RIGHT (ic);
785 /* if division by self then 1 */
786 if (IC_LEFT (ic)->key == IC_RIGHT (ic)->key)
789 IC_RIGHT (ic) = operandFromLit (1);
791 IC_RESULT (ic) = operandFromOperand (IC_RESULT (ic));
792 IC_RESULT (ic)->isaddr = 0;
795 /* if this is a division then check if right */
796 /* is one then change it to an assignment */
797 if (IS_OP_LITERAL (IC_RIGHT (ic)) &&
798 operandLitValue (IC_RIGHT (ic)) == 1.0)
802 IC_RIGHT (ic) = IC_LEFT (ic);
804 SET_RESULT_RIGHT (ic);
808 /* if both are the same for an comparison operators */
812 if (isOperandEqual (IC_LEFT (ic), IC_RIGHT (ic)))
815 IC_RIGHT (ic) = operandFromLit (1);
817 SET_RESULT_RIGHT (ic);
823 if (isOperandEqual (IC_LEFT (ic), IC_RIGHT (ic)))
826 IC_RIGHT (ic) = operandFromLit (0);
828 SET_RESULT_RIGHT (ic);
833 sym_link *otype = operandType(IC_RIGHT(ic));
834 sym_link *ctype = operandType(IC_LEFT(ic));
835 /* if this is a cast of a literal value */
836 if (IS_OP_LITERAL (IC_RIGHT (ic)) &&
837 !(IS_GENPTR(ctype) && (IS_PTR(otype) && !IS_GENPTR(otype)))) {
840 operandFromValue (valCastLiteral (operandType (IC_LEFT (ic)),
841 operandLitValue (IC_RIGHT (ic))));
843 SET_ISADDR (IC_RESULT (ic), 0);
845 /* if casting to the same */
846 if (compareType (operandType (IC_RESULT (ic)),
847 operandType (IC_RIGHT (ic))) == 1) {
850 SET_ISADDR (IC_RESULT (ic), 0);
855 if (IS_OP_LITERAL (IC_LEFT (ic)))
859 (operandLitValue (IC_LEFT (ic)) == 0 ?
860 operandFromLit (1) : operandFromLit (0));
862 SET_ISADDR (IC_RESULT (ic), 0);
868 #define OTHERS_PARM(s) (s->_isparm && !s->ismyparm)
869 /*-----------------------------------------------------------------*/
870 /* updateSpillLocation - keeps track of register spill location */
871 /*-----------------------------------------------------------------*/
873 updateSpillLocation (iCode * ic, int induction)
878 if (POINTER_SET (ic))
884 /* for the form true_symbol := iTempNN */
885 if (ASSIGN_ITEMP_TO_SYM (ic) &&
886 !SPIL_LOC (IC_RIGHT (ic))) {
888 setype = getSpec (operandType (IC_RESULT (ic)));
890 if (!OP_SYMBOL(IC_RIGHT (ic))->noSpilLoc &&
891 !IS_VOLATILE (setype) &&
892 !IN_FARSPACE (SPEC_OCLS (setype)) &&
893 !OTHERS_PARM (OP_SYMBOL (IC_RESULT (ic))))
895 SPIL_LOC (IC_RIGHT (ic)) =
896 IC_RESULT (ic)->operand.symOperand;
899 if (ASSIGN_ITEMP_TO_ITEMP (ic)) {
901 if (!SPIL_LOC (IC_RIGHT (ic)) &&
902 !bitVectBitsInCommon (OP_DEFS (IC_RIGHT (ic)), OP_USES (IC_RESULT (ic))) &&
903 OP_SYMBOL (IC_RESULT (ic))->isreqv) {
905 setype = getSpec (operandType (IC_RESULT (ic)));
907 if (!OP_SYMBOL(IC_RIGHT (ic))->noSpilLoc &&
908 !IS_VOLATILE (setype) &&
909 !IN_FARSPACE (SPEC_OCLS (setype)) &&
910 !OTHERS_PARM (OP_SYMBOL (IC_RESULT (ic))))
912 SPIL_LOC (IC_RIGHT (ic)) =
913 SPIL_LOC (IC_RESULT (ic));
915 /* special case for inductions */
917 OP_SYMBOL(IC_RIGHT(ic))->isreqv &&
918 !OP_SYMBOL(IC_RESULT (ic))->noSpilLoc &&
919 !SPIL_LOC(IC_RESULT(ic))) {
920 SPIL_LOC (IC_RESULT (ic)) = SPIL_LOC (IC_RIGHT (ic));
924 /*-----------------------------------------------------------------*/
925 /* setUsesDef - sets the uses def bitvector for a given operand */
926 /*-----------------------------------------------------------------*/
928 setUsesDefs (operand * op, bitVect * bdefs,
929 bitVect * idefs, bitVect ** oud)
931 /* compute the definitions alive at this point */
932 bitVect *adefs = bitVectUnion (bdefs, idefs);
934 /* of these definitions find the ones that are */
935 /* for this operand */
936 adefs = bitVectIntersect (adefs, OP_DEFS (op));
938 /* these are the definitions that this operand can use */
939 op->usesDefs = adefs;
941 /* the out defs is an union */
942 *oud = bitVectUnion (*oud, adefs);
945 /*-----------------------------------------------------------------*/
946 /* unsetDefsAndUses - clear this operation for the operands */
947 /*-----------------------------------------------------------------*/
949 unsetDefsAndUses (iCode * ic)
951 if (ic->op == JUMPTABLE)
954 /* take away this definition from the def chain of the */
955 /* result & take away from use set of the operands */
958 /* turn off def set */
959 if (IS_SYMOP (IC_RESULT (ic)))
961 if (!POINTER_SET (ic))
962 bitVectUnSetBit (OP_DEFS (IC_RESULT (ic)), ic->key);
964 bitVectUnSetBit (OP_USES (IC_RESULT (ic)), ic->key);
966 /* turn off the useSet for the operands */
967 if (IS_SYMOP (IC_LEFT (ic)))
968 bitVectUnSetBit (OP_USES (IC_LEFT (ic)), ic->key);
970 if (IS_SYMOP (IC_RIGHT (ic)))
971 bitVectUnSetBit (OP_USES (IC_RIGHT (ic)), ic->key);
974 /* must be ifx turn off the use */ if (IS_SYMOP (IC_COND (ic)))
975 bitVectUnSetBit (OP_USES (IC_COND (ic)), ic->key);
978 /*-----------------------------------------------------------------*/
979 /* ifxOptimize - changes ifx conditions if it can */
980 /*-----------------------------------------------------------------*/
982 ifxOptimize (iCode * ic, set * cseSet,
984 eBBlock * ebb, int *change,
985 eBBlock ** ebbs, int count)
990 /* if the condition can be replaced */
994 applyToSetFTrue (cseSet, findCheaperOp, IC_COND (ic), &pdop, 0);
1002 /* if the conditional is a literal then */
1003 if (IS_OP_LITERAL (IC_COND (ic)))
1006 if ((operandLitValue (IC_COND (ic)) != 0.0) && IC_TRUE (ic))
1009 /* change to a goto */
1011 IC_LABEL (ic) = IC_TRUE (ic);
1018 if (!operandLitValue (IC_COND (ic)) && IC_FALSE (ic))
1021 IC_LABEL (ic) = IC_FALSE (ic);
1027 /* then kill this if condition */
1028 remiCodeFromeBBlock (ebb, ic);
1032 /* now we need to recompute the control flow */
1033 /* since the control flow has changed */
1034 /* this is very expensive but it does not happen */
1035 /* too often, if it does happen then the user pays */
1037 computeControlFlow (ebbs, count, 1);
1038 if (!options.lessPedantic) {
1039 werror (W_CONTROL_FLOW, ic->filename, ic->lineno);
1044 /* if there is only one successor and that successor
1045 is the same one we are conditionally going to then
1046 we can remove this conditional statement */
1047 label = (IC_TRUE (ic) ? IC_TRUE (ic) : IC_FALSE (ic));
1048 if (elementsInSet (ebb->succList) == 1 &&
1049 isinSet (ebb->succList, eBBWithEntryLabel (ebbs, label, count)))
1052 remiCodeFromeBBlock (ebb, ic);
1053 computeControlFlow (ebbs, count, 1);
1054 if (!options.lessPedantic) {
1055 werror (W_CONTROL_FLOW, ic->filename, ic->lineno);
1061 /* if it remains an IFX the update the use Set */
1062 OP_USES (IC_COND (ic)) = bitVectSetBit (OP_USES (IC_COND (ic)), ic->key);
1063 setUsesDefs (IC_COND (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
1067 /*-----------------------------------------------------------------*/
1068 /* diCodeForSym - finds the definiting instruction for a symbol */
1069 /*-----------------------------------------------------------------*/
1070 DEFSETFUNC (diCodeForSym)
1073 V_ARG (operand *, sym);
1074 V_ARG (iCode **, dic);
1076 /* if already found */
1080 /* if not if this is the defining iCode */
1081 if (sym->key == cdp->key)
1090 /*-----------------------------------------------------------------*/
1091 /* constFold - does some constant folding */
1092 /*-----------------------------------------------------------------*/
1094 constFold (iCode * ic, set * cseSet)
1098 /* this routine will change
1104 /* deal with only + & - */
1105 if (ic->op != '+' &&
1109 /* this check is a hueristic to prevent live ranges
1110 from becoming too long */
1111 if (IS_PTR (operandType (IC_RESULT (ic))))
1114 /* check if operation with a literal */
1115 if (!IS_OP_LITERAL (IC_RIGHT (ic)))
1118 /* check if we can find a definition for the
1120 if (!(applyToSet (cseSet, diCodeForSym, IC_LEFT (ic), &dic)))
1123 /* check that this is also a +/- */
1124 if (dic->op != '+' && dic->op != '-')
1127 /* with a literal */
1128 if (!IS_OP_LITERAL (IC_RIGHT (dic)))
1131 /* find the definition of the left operand
1132 of dic.then check if this defined with a
1133 get_pointer return 0 if the pointer size is
1134 less than 2 (MCS51 specific) */
1135 if (!(applyToSet (cseSet, diCodeForSym, IC_LEFT (dic), &ldic)))
1138 if (POINTER_GET (ldic) && getSize (operandType (IC_LEFT (ldic))) <= 1)
1141 /* it is if the operations are the same */
1142 /* the literal parts need to be added */
1143 IC_LEFT (ic) = operandFromOperand (IC_LEFT (dic));
1144 if (ic->op == dic->op)
1145 IC_RIGHT (ic) = operandFromLit (operandLitValue (IC_RIGHT (ic)) +
1146 operandLitValue (IC_RIGHT (dic)));
1148 IC_RIGHT (ic) = operandFromLit (operandLitValue (IC_RIGHT (ic)) -
1149 operandLitValue (IC_RIGHT (dic)));
1151 if (IS_ITEMP (IC_RESULT (ic)))
1153 SPIL_LOC (IC_RESULT (ic)) = NULL;
1154 OP_SYMBOL(IC_RESULT (ic))->noSpilLoc = 1;
1161 /*-----------------------------------------------------------------*/
1162 /* deleteGetPointers - called when a pointer is passed as parm */
1163 /* will delete from cseSet all get pointers computed from this */
1164 /* pointer. A simple ifOperandsHave is not good enough here */
1165 /*-----------------------------------------------------------------*/
1167 deleteGetPointers (set ** cseSet, set ** pss, operand * op, eBBlock * ebb)
1169 set *compItems = NULL;
1174 if (!*cseSet && !*pss)
1177 /* first find all items computed from this operand .
1178 This done fairly simply go thru the list and find
1179 those that are computed by arthimetic with this
1181 for (cdp = setFirstItem (*cseSet); cdp; cdp = setNextItem (*cseSet))
1183 if (IS_ARITHMETIC_OP (cdp->diCode))
1185 if (isOperandEqual (IC_LEFT (cdp->diCode), op) ||
1186 isOperandEqual (IC_RIGHT (cdp->diCode), op))
1188 /* save it in our list of items */
1189 addSet (&compItems, IC_RESULT (cdp->diCode));
1191 /* also check for those computed from our computed
1192 list . This will take care of situations like
1193 iTemp1 = iTemp0 + 8;
1194 iTemp2 = iTemp1 + 8; */
1195 if (isinSetWith (compItems, (void*)IC_LEFT (cdp->diCode),
1196 (insetwithFunc)isOperandEqual) ||
1197 isinSetWith (compItems, (void*)IC_RIGHT (cdp->diCode),
1198 (insetwithFunc)isOperandEqual))
1200 addSet (&compItems, IC_RESULT (cdp->diCode));
1205 /* now delete all pointer gets with this op */
1206 deleteItemIf (cseSet, ifPointerGet, op);
1207 deleteItemIf (pss, ifPointerSet, op);
1209 /* set the bit vector used by dataFlow computation later */
1210 ebb->ptrsSet = bitVectSetBit (ebb->ptrsSet, op->key);
1211 /* now for the computed items */
1212 for (cop = setFirstItem (compItems); cop; cop = setNextItem (compItems))
1214 ebb->ptrsSet = bitVectSetBit (ebb->ptrsSet, cop->key);
1215 deleteItemIf (cseSet, ifPointerGet, cop);
1216 deleteItemIf (pss, ifPointerSet, cop);
1220 /*-----------------------------------------------------------------*/
1221 /* delGetPointerSucc - delete get pointer from inExprs of succ with */
1222 /* dfnum > supplied */
1223 /*-----------------------------------------------------------------*/
1224 DEFSETFUNC (delGetPointerSucc)
1226 eBBlock *ebp = item;
1227 V_ARG (operand *, op);
1234 if (ebp->dfnum > dfnum)
1236 deleteItemIf (&ebp->inExprs, ifPointerGet, op);
1239 return applyToSet (ebp->succList, delGetPointerSucc, op, dfnum);
1242 /*-----------------------------------------------------------------*/
1243 /* fixUpTypes - KLUGE HACK fixup a lowering problem */
1244 /*-----------------------------------------------------------------*/
1246 fixUpTypes (iCode * ic)
1248 sym_link *t1 = operandType (IC_LEFT (ic)), *t2;
1250 /* if (TARGET_IS_DS390) */
1251 if (options.model == MODEL_FLAT24)
1257 /* for pointer_gets if the types of result & left r the
1258 same then change it type of result to next */
1260 compareType (t2 = operandType (IC_RESULT (ic)), t1) == 1)
1262 setOperandType (IC_RESULT (ic), t2->next);
1266 /*-----------------------------------------------------------------*/
1267 /* isSignedOp - will return 1 if sign is important to operation */
1268 /*-----------------------------------------------------------------*/
1269 static int isSignedOp (iCode *ic)
1290 case GET_VALUE_AT_ADDRESS:
1315 /*-----------------------------------------------------------------*/
1316 /* cseBBlock - common subexpression elimination for basic blocks */
1317 /* this is the hackiest kludgiest routine in the whole */
1318 /* system. also the most important, since almost all */
1319 /* data flow related information is computed by it */
1320 /*-----------------------------------------------------------------*/
1322 cseBBlock (eBBlock * ebb, int computeOnly,
1323 eBBlock ** ebbs, int count)
1329 set *ptrSetSet = NULL;
1331 /* if this block is not reachable */
1335 /* set of common subexpressions */
1336 cseSet = setFromSet (ebb->inExprs);
1338 /* these will be computed by this routine */
1339 setToNull ((void **) &ebb->outDefs);
1340 setToNull ((void **) &ebb->defSet);
1341 setToNull ((void **) &ebb->usesDefs);
1342 setToNull ((void **) &ebb->ptrsSet);
1343 setToNull ((void **) &ebb->addrOf);
1344 setToNull ((void **) &ebb->ldefs);
1346 ebb->outDefs = bitVectCopy (ebb->inDefs);
1347 bitVectDefault = iCodeKey;
1348 ebb->defSet = newBitVect (iCodeKey);
1349 ebb->usesDefs = newBitVect (iCodeKey);
1351 /* for all the instructions in this block do */
1352 for (ic = ebb->sch; ic; ic = ic->next)
1360 ic->eBBlockNum = ebb->bbnum;
1365 /* if this is an assignment from true symbol
1366 to a temp then do pointer post inc/dec optimzation */
1367 if (ic->op == '=' && !POINTER_SET (ic) &&
1368 IS_PTR (operandType (IC_RESULT (ic))))
1370 ptrPostIncDecOpt (ic);
1373 /* clear the def & use chains for the operands involved */
1374 /* in this operation . since it can change due to opts */
1375 unsetDefsAndUses (ic);
1377 if (ic->op == PCALL || ic->op == CALL || ic->op == RECEIVE)
1379 /* add to defSet of the symbol */
1380 OP_DEFS (IC_RESULT (ic)) =
1381 bitVectSetBit (OP_DEFS (IC_RESULT (ic)), ic->key);
1382 /* add to the definition set of this block */
1383 ebb->defSet = bitVectSetBit (ebb->defSet, ic->key);
1384 ebb->ldefs = bitVectSetBit (ebb->ldefs, ic->key);
1385 ebb->outDefs = bitVectCplAnd (ebb->outDefs, OP_DEFS (IC_RESULT (ic)));
1386 setUsesDefs (IC_RESULT (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
1387 /* delete global variables from the cseSet
1388 since they can be modified by the function call */
1389 deleteItemIf (&cseSet, ifDefGlobal);
1391 /* and also itemps assigned from globals */
1392 deleteItemIf (&cseSet, ifAssignedFromGlobal);
1394 /* delete all getpointer iCodes from cseSet, this should
1395 be done only for global arrays & pointers but at this
1396 point we don't know if globals, so to be safe do all */
1397 deleteItemIf (&cseSet, ifAnyGetPointer);
1400 /* for pcall & ipush we need to add to the useSet */
1401 if ((ic->op == PCALL ||
1405 IS_SYMOP (IC_LEFT (ic)))
1408 /* check if they can be replaced */
1412 applyToSetFTrue (cseSet, findCheaperOp, IC_LEFT (ic), &pdop, 0);
1414 IC_LEFT (ic) = pdop;
1416 /* the lookup could have changed it */
1417 if (IS_SYMOP (IC_LEFT (ic)))
1419 OP_USES (IC_LEFT (ic)) =
1420 bitVectSetBit (OP_USES (IC_LEFT (ic)), ic->key);
1421 setUsesDefs (IC_LEFT (ic), ebb->defSet,
1422 ebb->outDefs, &ebb->usesDefs);
1426 /* if we a sending a pointer as a parameter
1427 then kill all cse since the pointed to item
1428 might be changed in the function being called */
1429 if ((ic->op == IPUSH || ic->op == SEND) &&
1430 IS_PTR (operandType (IC_LEFT (ic))))
1432 deleteGetPointers (&cseSet, &ptrSetSet, IC_LEFT (ic), ebb);
1433 ebb->ptrsSet = bitVectSetBit (ebb->ptrsSet, IC_LEFT (ic)->key);
1434 for (i = 0; i < count; ebbs[i++]->visited = 0);
1435 applyToSet (ebb->succList, delGetPointerSucc,
1436 IC_LEFT (ic), ebb->dfnum);
1441 /* if jumptable then mark the usage */
1442 if (ic->op == JUMPTABLE)
1444 OP_USES (IC_JTCOND (ic)) =
1445 bitVectSetBit (OP_USES (IC_JTCOND (ic)), ic->key);
1446 setUsesDefs (IC_JTCOND (ic), ebb->defSet,
1447 ebb->outDefs, &ebb->usesDefs);
1454 /* do some algebraic optimizations if possible */
1456 while (constFold (ic, cseSet));
1459 if (POINTER_GET (ic) && !IS_PTR (operandType (IC_LEFT (ic))))
1461 setOperandType (IC_LEFT (ic),
1462 aggrToPtr (operandType (IC_LEFT (ic)), FALSE));
1466 if (POINTER_SET (ic) && !IS_PTR (operandType (IC_RESULT (ic))))
1468 setOperandType (IC_RESULT (ic),
1469 aggrToPtr (operandType (IC_RESULT (ic)), FALSE));
1472 /* if this is a condition statment then */
1473 /* check if the condition can be replaced */
1476 ifxOptimize (ic, cseSet, computeOnly,
1482 /* if the assignment & result is a temp */
1483 /* see if we can replace it */
1487 /* update the spill location for this */
1488 updateSpillLocation (ic,0);
1490 if (POINTER_SET (ic) &&
1491 !(IS_BITFIELD (OP_SYMBOL (IC_RESULT (ic))->etype)))
1494 applyToSetFTrue (cseSet, findCheaperOp, IC_RESULT (ic), &pdop, 0);
1495 if (pdop && IS_ITEMP (pdop) && !computeOnly)
1496 IC_RESULT (ic) = pdop;
1500 checkSign = isSignedOp(ic);
1502 /* do the operand lookup i.e. for both the */
1503 /* right & left operand : check the cseSet */
1504 /* to see if they have been replaced if yes */
1505 /* then replace them with those from cseSet */
1507 /* and left is a symbol */
1508 if (IS_SYMOP (IC_LEFT (ic)) &&
1509 !computeOnly && ic->op != ADDRESS_OF)
1513 applyToSetFTrue (cseSet, findCheaperOp, IC_LEFT (ic), &pdop, checkSign);
1516 if (POINTER_GET (ic))
1518 if (IS_ITEMP (pdop) || IS_OP_LITERAL (pdop))
1520 IC_LEFT (ic) = pdop;
1523 /* check if there is a pointer set
1524 for the same pointer visible if yes
1525 then change this into an assignment */
1527 if (applyToSetFTrue (cseSet, findPointerSet, IC_LEFT (ic), &pdop, IC_RESULT (ic)) &&
1528 !bitVectBitValue (ebb->ptrsSet, pdop->key))
1531 IC_LEFT (ic) = NULL;
1532 IC_RIGHT (ic) = pdop;
1533 SET_ISADDR (IC_RESULT (ic), 0);
1539 IC_LEFT (ic) = pdop;
1546 if (IS_SYMOP (IC_RIGHT (ic)) && !computeOnly)
1550 applyToSetFTrue (cseSet, findCheaperOp, IC_RIGHT (ic), &pdop, checkSign);
1553 IC_RIGHT (ic) = pdop;
1558 /* if left or right changed then do algebraic */
1562 while (constFold (ic, cseSet));
1565 /* if after all this it becomes a assignment to self
1566 then delete it and continue */
1567 if (ASSIGNMENT_TO_SELF (ic))
1569 remiCodeFromeBBlock (ebb, ic);
1573 /* now we will check to see if the entire */
1574 /* operation has been performed before */
1575 /* and is available */
1576 /* don't do assignments they will be killed */
1577 /* by dead code elimination if required do */
1578 /* it only if result is a temporary */
1580 if (!(POINTER_GET (ic) &&
1581 (IS_BITFIELD (OP_SYMBOL (IC_RESULT (ic))->etype) ||
1582 isOperandVolatile (IC_LEFT (ic), TRUE) ||
1583 bitVectBitValue (ebb->ndompset, IC_LEFT (ic)->key))) &&
1585 IS_ITEMP (IC_RESULT (ic)) &&
1588 applyToSet (cseSet, findPrevIc, ic, &pdic);
1589 if (pdic && compareType (operandType (IC_RESULT (pdic)),
1590 operandType (IC_RESULT (ic))) != 1)
1592 if (pdic && port->cseOk && (*port->cseOk)(ic,pdic) == 0)
1596 /* Alternate code */
1597 if (pdic && IS_ITEMP(IC_RESULT(ic))) {
1598 /* if previous definition found change this to an assignment */
1601 IC_RIGHT(ic) = operandFromOperand(IC_RESULT(pdic));
1602 SET_ISADDR(IC_RESULT(ic),0);
1603 SET_ISADDR(IC_RIGHT (ic),0);
1606 if (!(POINTER_SET (ic)) && IC_RESULT (ic)) {
1607 deleteItemIf (&cseSet, ifDefSymIsX, IC_RESULT (ic));
1608 addSetHead (&cseSet, newCseDef (IC_RESULT (ic), ic));
1612 /* if assignment to a parameter which is not
1613 mine and type is a pointer then delete
1614 pointerGets to take care of aliasing */
1615 if (ASSIGNMENT (ic) &&
1616 OTHERS_PARM (OP_SYMBOL (IC_RESULT (ic))) &&
1617 IS_PTR (operandType (IC_RESULT (ic))))
1619 deleteGetPointers (&cseSet, &ptrSetSet, IC_RIGHT (ic), ebb);
1620 for (i = 0; i < count; ebbs[i++]->visited = 0);
1621 applyToSet (ebb->succList, delGetPointerSucc, IC_RIGHT (ic), ebb->dfnum);
1622 ebb->ptrsSet = bitVectSetBit (ebb->ptrsSet, IC_RIGHT (ic)->key);
1625 /* if this is a pointerget then see if we can replace
1626 this with a previously assigned pointer value */
1627 if (POINTER_GET (ic) &&
1628 !(IS_BITFIELD (OP_SYMBOL (IC_RESULT (ic))->etype) ||
1629 isOperandVolatile (IC_LEFT (ic), TRUE)))
1632 applyToSet (ptrSetSet, findPointerSet, IC_LEFT (ic), &pdop, IC_RESULT (ic));
1633 /* if we find it then locally replace all
1634 references to the result with what we assigned */
1637 replaceAllSymBySym (ic->next, IC_RESULT (ic), pdop, &ebb->ndompset);
1641 /* delete from the cseSet anything that has */
1642 /* operands matching the result of this */
1643 /* except in case of pointer access */
1644 if (!(POINTER_SET (ic)) && IC_RESULT (ic))
1646 deleteItemIf (&cseSet, ifOperandsHave, IC_RESULT (ic));
1647 /* delete any previous definitions */
1648 ebb->defSet = bitVectCplAnd (ebb->defSet, OP_DEFS (IC_RESULT (ic)));
1652 /* add the left & right to the defUse set */
1653 if (IC_LEFT (ic) && IS_SYMOP (IC_LEFT (ic)))
1655 OP_USES (IC_LEFT (ic)) =
1656 bitVectSetBit (OP_USES (IC_LEFT (ic)), ic->key);
1657 setUsesDefs (IC_LEFT (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
1661 if (IC_RIGHT (ic) && IS_SYMOP (IC_RIGHT (ic)))
1663 OP_USES (IC_RIGHT (ic)) =
1664 bitVectSetBit (OP_USES (IC_RIGHT (ic)), ic->key);
1665 setUsesDefs (IC_RIGHT (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
1669 /* for the result it is special case, put the result */
1670 /* in the defuseSet if it a pointer or array access */
1671 if (POINTER_SET (defic))
1673 OP_USES (IC_RESULT (ic)) =
1674 bitVectSetBit (OP_USES (IC_RESULT (ic)), ic->key);
1675 setUsesDefs (IC_RESULT (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
1676 deleteItemIf (&cseSet, ifPointerGet, IC_RESULT (ic));
1677 ebb->ptrsSet = bitVectSetBit (ebb->ptrsSet, IC_RESULT (ic)->key);
1678 /* delete from inexpressions of all successors which
1679 have dfNum > than this block */
1680 for (i = 0; i < count; ebbs[i++]->visited = 0);
1681 applyToSet (ebb->succList, delGetPointerSucc, IC_RESULT (ic), ebb->dfnum);
1683 /* delete from cseSet all other pointer sets
1685 deleteItemIf (&ptrSetSet, ifPointerSet, IC_RESULT (ic));
1686 /* add to the local pointerset set */
1687 addSetHead (&ptrSetSet, newCseDef (IC_RESULT (ic), ic));
1690 /* add the result to defintion set */ if (IC_RESULT (ic))
1692 OP_DEFS (IC_RESULT (ic)) =
1693 bitVectSetBit (OP_DEFS (IC_RESULT (ic)), ic->key);
1694 ebb->defSet = bitVectSetBit (ebb->defSet, ic->key);
1695 ebb->outDefs = bitVectCplAnd (ebb->outDefs, OP_DEFS (IC_RESULT (ic)));
1696 ebb->ldefs = bitVectSetBit (ebb->ldefs, ic->key);
1700 /* if this is an addressof instruction then */
1701 /* put the symbol in the address of list & */
1702 /* delete it from the cseSet */
1703 if (defic->op == ADDRESS_OF)
1705 addSetHead (&ebb->addrOf, IC_LEFT (ic));
1706 deleteItemIf (&cseSet, ifDefSymIsX, IC_LEFT (ic));
1710 setToNull ((void **) &ebb->outExprs);
1711 ebb->outExprs = cseSet;
1712 ebb->outDefs = bitVectUnion (ebb->outDefs, ebb->defSet);
1713 ebb->ptrsSet = bitVectUnion (ebb->ptrsSet, ebb->inPtrsSet);
1717 /*-----------------------------------------------------------------*/
1718 /* cseAllBlocks - will sequentially go thru & do cse for all blocks */
1719 /*-----------------------------------------------------------------*/
1721 cseAllBlocks (eBBlock ** ebbs, int count)
1726 /* if optimization turned off */
1728 for (i = 0; i < count; i++)
1729 change += cseBBlock (ebbs[i], FALSE, ebbs, count);