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_SET ((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_SET ((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_SET ((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_SET ((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_SET ((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_SET ((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 /* findBackwardDef - scan backwards to find deinition of operand */
576 /*-----------------------------------------------------------------*/
577 iCode *findBackwardDef(operand *op,iCode *ic)
581 for (lic = ic; lic ; lic = lic->prev) {
582 if (IC_RESULT(lic) && isOperandEqual(op,IC_RESULT(lic)))
588 /*-----------------------------------------------------------------*/
589 /* algebraicOpts - does some algebraic optimizations */
590 /*-----------------------------------------------------------------*/
592 algebraicOpts (iCode * ic)
594 /* we don't deal with the following iCodes
605 /* if both operands present & ! IFX */
606 /* then if they are both literal we */
607 /* perform the operation right now */
608 if (IC_RESULT (ic) &&
611 IS_OP_LITERAL (IC_LEFT (ic)) &&
612 IS_OP_LITERAL (IC_RIGHT (ic)))
615 IC_RIGHT (ic) = operandOperation (IC_LEFT (ic),
618 operandType (IC_RESULT (ic)));
621 SET_RESULT_RIGHT (ic);
625 /* if not ifx & only one operand present */
626 if (IC_RESULT (ic) &&
628 IS_OP_LITERAL (IC_LEFT (ic)) &&
632 IC_RIGHT (ic) = operandOperation (IC_LEFT (ic),
635 operandType (IC_RESULT (ic)));
638 SET_RESULT_RIGHT (ic);
643 /* a special case : or in short a kludgy solution will think
644 about a better solution over a glass of wine someday */
645 if (ic->op == GET_VALUE_AT_ADDRESS)
648 if (IS_ITEMP (IC_RESULT (ic)) &&
649 IS_TRUE_SYMOP (IC_LEFT (ic)))
653 IC_RIGHT (ic) = operandFromOperand (IC_LEFT (ic));
654 IC_RIGHT (ic)->isaddr = 0;
656 IC_RESULT (ic) = operandFromOperand (IC_RESULT (ic));
657 IC_RESULT (ic)->isaddr = 0;
658 setOperandType (IC_RESULT (ic), operandType (IC_RIGHT (ic)));
662 if (IS_ITEMP (IC_LEFT (ic)) &&
663 IS_ITEMP (IC_RESULT (ic)) &&
664 /* !OP_SYMBOL(IC_RESULT(ic))->isreqv && */
665 /* !OP_SYMBOL(IC_LEFT(ic))->isreqv && */
666 !IC_LEFT (ic)->isaddr)
669 IC_RIGHT (ic) = operandFromOperand (IC_LEFT (ic));
670 IC_RIGHT (ic)->isaddr = 0;
671 IC_RESULT (ic) = operandFromOperand (IC_RESULT (ic));
672 IC_RESULT (ic)->isaddr = 0;
680 /* depending on the operation */
684 /* if adding the same thing change to left shift by 1 */
685 if (IC_LEFT (ic)->key == IC_RIGHT (ic)->key &&
686 !IS_FLOAT (operandType (IC_RESULT (ic))))
689 IC_RIGHT (ic) = operandFromLit (1);
692 /* if addition then check if one of them is a zero */
693 /* if yes turn it into assignmnt */
694 if (IS_OP_LITERAL (IC_LEFT (ic)) &&
695 operandLitValue (IC_LEFT (ic)) == 0.0)
700 SET_ISADDR (IC_RESULT (ic), 0);
701 SET_ISADDR (IC_RIGHT (ic), 0);
704 if (IS_OP_LITERAL (IC_RIGHT (ic)) &&
705 operandLitValue (IC_RIGHT (ic)) == 0.0)
709 IC_RIGHT (ic) = IC_LEFT (ic);
711 SET_ISADDR (IC_RIGHT (ic), 0);
712 SET_ISADDR (IC_RESULT (ic), 0);
717 /* if subtracting the the same thing then zero */
718 if (IC_LEFT (ic)->key == IC_RIGHT (ic)->key)
721 IC_RIGHT (ic) = operandFromLit (0);
723 IC_RESULT (ic) = operandFromOperand (IC_RESULT (ic));
724 IC_RESULT (ic)->isaddr = 0;
728 /* if subtraction then check if one of the operand */
729 /* is zero then depending on which operand change */
730 /* to assignment or unary minus */
731 if (IS_OP_LITERAL (IC_RIGHT (ic)) &&
732 operandLitValue (IC_RIGHT (ic)) == 0.0)
734 /* right size zero change to assignment */
736 IC_RIGHT (ic) = IC_LEFT (ic);
738 SET_ISADDR (IC_RIGHT (ic), 0);
739 SET_ISADDR (IC_RESULT (ic), 0);
742 if (IS_OP_LITERAL (IC_LEFT (ic)) &&
743 operandLitValue (IC_LEFT (ic)) == 0.0)
745 /* left zero turn into an unary minus */
747 IC_LEFT (ic) = IC_RIGHT (ic);
748 IC_RIGHT (ic) = NULL;
752 /* if multiplication then check if either of */
753 /* them is zero then the result is zero */
754 /* if either of them is one then result is */
757 if (IS_OP_LITERAL (IC_LEFT (ic)))
760 if (operandLitValue (IC_LEFT (ic)) == 0.0)
763 IC_RIGHT (ic) = IC_LEFT (ic);
765 SET_RESULT_RIGHT (ic);
768 if (operandLitValue (IC_LEFT (ic)) == 1.0)
772 SET_RESULT_RIGHT (ic);
777 if (IS_OP_LITERAL (IC_RIGHT (ic)))
780 if (operandLitValue (IC_RIGHT (ic)) == 0.0)
784 SET_RESULT_RIGHT (ic);
788 if (operandLitValue (IC_RIGHT (ic)) == 1.0)
791 IC_RIGHT (ic) = IC_LEFT (ic);
793 SET_RESULT_RIGHT (ic);
799 /* if division by self then 1 */
800 if (IC_LEFT (ic)->key == IC_RIGHT (ic)->key)
803 IC_RIGHT (ic) = operandFromLit (1);
805 IC_RESULT (ic) = operandFromOperand (IC_RESULT (ic));
806 IC_RESULT (ic)->isaddr = 0;
809 /* if this is a division then check if right */
810 /* is one then change it to an assignment */
811 if (IS_OP_LITERAL (IC_RIGHT (ic)) &&
812 operandLitValue (IC_RIGHT (ic)) == 1.0)
816 IC_RIGHT (ic) = IC_LEFT (ic);
818 SET_RESULT_RIGHT (ic);
822 /* if both are the same for an comparison operators */
826 if (isOperandEqual (IC_LEFT (ic), IC_RIGHT (ic)))
829 IC_RIGHT (ic) = operandFromLit (1);
831 SET_RESULT_RIGHT (ic);
837 if (isOperandEqual (IC_LEFT (ic), IC_RIGHT (ic)))
840 IC_RIGHT (ic) = operandFromLit (0);
842 SET_RESULT_RIGHT (ic);
847 sym_link *otype = operandType(IC_RIGHT(ic));
848 sym_link *ctype = operandType(IC_LEFT(ic));
849 /* if this is a cast of a literal value */
850 if (IS_OP_LITERAL (IC_RIGHT (ic)) &&
851 !(IS_GENPTR(ctype) && (IS_PTR(otype) && !IS_GENPTR(otype)))) {
854 operandFromValue (valCastLiteral (operandType (IC_LEFT (ic)),
855 operandLitValue (IC_RIGHT (ic))));
857 SET_ISADDR (IC_RESULT (ic), 0);
859 /* if casting to the same */
860 if (compareType (operandType (IC_RESULT (ic)),
861 operandType (IC_RIGHT (ic))) == 1) {
864 SET_ISADDR (IC_RESULT (ic), 0);
869 if (IS_OP_LITERAL (IC_LEFT (ic)))
873 (operandLitValue (IC_LEFT (ic)) == 0 ?
874 operandFromLit (1) : operandFromLit (0));
876 SET_ISADDR (IC_RESULT (ic), 0);
882 #define OTHERS_PARM(s) (s->_isparm && !s->ismyparm)
883 /*-----------------------------------------------------------------*/
884 /* updateSpillLocation - keeps track of register spill location */
885 /*-----------------------------------------------------------------*/
887 updateSpillLocation (iCode * ic, int induction)
892 if (POINTER_SET (ic))
898 /* for the form true_symbol := iTempNN */
899 if (ASSIGN_ITEMP_TO_SYM (ic) &&
900 !SPIL_LOC (IC_RIGHT (ic))) {
902 setype = getSpec (operandType (IC_RESULT (ic)));
904 if (!OP_SYMBOL(IC_RIGHT (ic))->noSpilLoc &&
905 !IS_VOLATILE (setype) &&
906 !IN_FARSPACE (SPEC_OCLS (setype)) &&
907 !OTHERS_PARM (OP_SYMBOL (IC_RESULT (ic))))
909 SPIL_LOC (IC_RIGHT (ic)) =
910 IC_RESULT (ic)->operand.symOperand;
913 #if 0 /* this needs furthur investigation can save a lot of code */
914 if (ASSIGN_SYM_TO_ITEMP(ic) &&
915 !SPIL_LOC(IC_RESULT(ic))) {
916 if (!OTHERS_PARM (OP_SYMBOL (IC_RIGHT (ic))))
917 SPIL_LOC (IC_RESULT (ic)) =
918 IC_RIGHT (ic)->operand.symOperand;
921 if (ASSIGN_ITEMP_TO_ITEMP (ic)) {
923 if (!SPIL_LOC (IC_RIGHT (ic)) &&
924 !bitVectBitsInCommon (OP_DEFS (IC_RIGHT (ic)), OP_USES (IC_RESULT (ic))) &&
925 OP_SYMBOL (IC_RESULT (ic))->isreqv) {
927 setype = getSpec (operandType (IC_RESULT (ic)));
929 if (!OP_SYMBOL(IC_RIGHT (ic))->noSpilLoc &&
930 !IS_VOLATILE (setype) &&
931 !IN_FARSPACE (SPEC_OCLS (setype)) &&
932 !OTHERS_PARM (OP_SYMBOL (IC_RESULT (ic))))
934 SPIL_LOC (IC_RIGHT (ic)) =
935 SPIL_LOC (IC_RESULT (ic));
937 /* special case for inductions */
939 OP_SYMBOL(IC_RIGHT(ic))->isreqv &&
940 !OP_SYMBOL(IC_RESULT (ic))->noSpilLoc &&
941 !SPIL_LOC(IC_RESULT(ic))) {
942 SPIL_LOC (IC_RESULT (ic)) = SPIL_LOC (IC_RIGHT (ic));
946 /*-----------------------------------------------------------------*/
947 /* setUsesDef - sets the uses def bitvector for a given operand */
948 /*-----------------------------------------------------------------*/
950 setUsesDefs (operand * op, bitVect * bdefs,
951 bitVect * idefs, bitVect ** oud)
953 /* compute the definitions alive at this point */
954 bitVect *adefs = bitVectUnion (bdefs, idefs);
956 /* of these definitions find the ones that are */
957 /* for this operand */
958 adefs = bitVectIntersect (adefs, OP_DEFS (op));
960 /* these are the definitions that this operand can use */
961 op->usesDefs = adefs;
963 /* the out defs is an union */
964 *oud = bitVectUnion (*oud, adefs);
967 /*-----------------------------------------------------------------*/
968 /* unsetDefsAndUses - clear this operation for the operands */
969 /*-----------------------------------------------------------------*/
971 unsetDefsAndUses (iCode * ic)
973 if (ic->op == JUMPTABLE)
976 /* take away this definition from the def chain of the */
977 /* result & take away from use set of the operands */
980 /* turn off def set */
981 if (IS_SYMOP (IC_RESULT (ic)))
983 if (!POINTER_SET (ic))
984 bitVectUnSetBit (OP_DEFS (IC_RESULT (ic)), ic->key);
986 bitVectUnSetBit (OP_USES (IC_RESULT (ic)), ic->key);
988 /* turn off the useSet for the operands */
989 if (IS_SYMOP (IC_LEFT (ic)))
990 bitVectUnSetBit (OP_USES (IC_LEFT (ic)), ic->key);
992 if (IS_SYMOP (IC_RIGHT (ic)))
993 bitVectUnSetBit (OP_USES (IC_RIGHT (ic)), ic->key);
996 /* must be ifx turn off the use */ if (IS_SYMOP (IC_COND (ic)))
997 bitVectUnSetBit (OP_USES (IC_COND (ic)), ic->key);
1000 /*-----------------------------------------------------------------*/
1001 /* ifxOptimize - changes ifx conditions if it can */
1002 /*-----------------------------------------------------------------*/
1004 ifxOptimize (iCode * ic, set * cseSet,
1006 eBBlock * ebb, int *change,
1007 eBBlock ** ebbs, int count)
1012 /* if the condition can be replaced */
1016 applyToSetFTrue (cseSet, findCheaperOp, IC_COND (ic), &pdop, 0);
1019 IC_COND (ic) = pdop;
1024 /* if the conditional is a literal then */
1025 if (IS_OP_LITERAL (IC_COND (ic)))
1028 if ((operandLitValue (IC_COND (ic)) != 0.0) && IC_TRUE (ic))
1031 /* change to a goto */
1033 IC_LABEL (ic) = IC_TRUE (ic);
1040 if (!operandLitValue (IC_COND (ic)) && IC_FALSE (ic))
1043 IC_LABEL (ic) = IC_FALSE (ic);
1049 /* then kill this if condition */
1050 remiCodeFromeBBlock (ebb, ic);
1054 /* now we need to recompute the control flow */
1055 /* since the control flow has changed */
1056 /* this is very expensive but it does not happen */
1057 /* too often, if it does happen then the user pays */
1059 computeControlFlow (ebbs, count, 1);
1060 if (!options.lessPedantic) {
1061 werror (W_CONTROL_FLOW, ic->filename, ic->lineno);
1066 /* if there is only one successor and that successor
1067 is the same one we are conditionally going to then
1068 we can remove this conditional statement */
1069 label = (IC_TRUE (ic) ? IC_TRUE (ic) : IC_FALSE (ic));
1070 if (elementsInSet (ebb->succList) == 1 &&
1071 isinSet (ebb->succList, eBBWithEntryLabel (ebbs, label, count)))
1074 remiCodeFromeBBlock (ebb, ic);
1075 computeControlFlow (ebbs, count, 1);
1076 if (!options.lessPedantic) {
1077 werror (W_CONTROL_FLOW, ic->filename, ic->lineno);
1083 /* if it remains an IFX the update the use Set */
1084 OP_USES_SET ((IC_COND (ic)), bitVectSetBit (OP_USES (IC_COND (ic)), ic->key));
1085 setUsesDefs (IC_COND (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
1089 /*-----------------------------------------------------------------*/
1090 /* diCodeForSym - finds the definiting instruction for a symbol */
1091 /*-----------------------------------------------------------------*/
1092 DEFSETFUNC (diCodeForSym)
1095 V_ARG (operand *, sym);
1096 V_ARG (iCode **, dic);
1098 /* if already found */
1102 /* if not if this is the defining iCode */
1103 if (sym->key == cdp->key)
1112 /*-----------------------------------------------------------------*/
1113 /* constFold - does some constant folding */
1114 /*-----------------------------------------------------------------*/
1116 constFold (iCode * ic, set * cseSet)
1120 /* this routine will change
1126 /* deal with only + & - */
1127 if (ic->op != '+' &&
1131 /* this check is a hueristic to prevent live ranges
1132 from becoming too long */
1133 if (IS_PTR (operandType (IC_RESULT (ic))))
1136 /* check if operation with a literal */
1137 if (!IS_OP_LITERAL (IC_RIGHT (ic)))
1140 /* check if we can find a definition for the
1142 if (!(applyToSet (cseSet, diCodeForSym, IC_LEFT (ic), &dic)))
1145 /* check that this is also a +/- */
1146 if (dic->op != '+' && dic->op != '-')
1149 /* with a literal */
1150 if (!IS_OP_LITERAL (IC_RIGHT (dic)))
1153 /* find the definition of the left operand
1154 of dic.then check if this defined with a
1155 get_pointer return 0 if the pointer size is
1156 less than 2 (MCS51 specific) */
1157 if (!(applyToSet (cseSet, diCodeForSym, IC_LEFT (dic), &ldic)))
1160 if (POINTER_GET (ldic) && getSize (operandType (IC_LEFT (ldic))) <= 1)
1163 /* it is if the operations are the same */
1164 /* the literal parts need to be added */
1165 IC_LEFT (ic) = operandFromOperand (IC_LEFT (dic));
1166 if (ic->op == dic->op)
1167 IC_RIGHT (ic) = operandFromLit (operandLitValue (IC_RIGHT (ic)) +
1168 operandLitValue (IC_RIGHT (dic)));
1170 IC_RIGHT (ic) = operandFromLit (operandLitValue (IC_RIGHT (ic)) -
1171 operandLitValue (IC_RIGHT (dic)));
1173 if (IS_ITEMP (IC_RESULT (ic)))
1175 SPIL_LOC (IC_RESULT (ic)) = NULL;
1176 OP_SYMBOL(IC_RESULT (ic))->noSpilLoc = 1;
1183 /*-----------------------------------------------------------------*/
1184 /* deleteGetPointers - called when a pointer is passed as parm */
1185 /* will delete from cseSet all get pointers computed from this */
1186 /* pointer. A simple ifOperandsHave is not good enough here */
1187 /*-----------------------------------------------------------------*/
1189 deleteGetPointers (set ** cseSet, set ** pss, operand * op, eBBlock * ebb)
1191 set *compItems = NULL;
1196 if (!*cseSet && !*pss)
1199 /* first find all items computed from this operand .
1200 This done fairly simply go thru the list and find
1201 those that are computed by arthimetic with this
1203 for (cdp = setFirstItem (*cseSet); cdp; cdp = setNextItem (*cseSet))
1205 if (IS_ARITHMETIC_OP (cdp->diCode))
1207 if (isOperandEqual (IC_LEFT (cdp->diCode), op) ||
1208 isOperandEqual (IC_RIGHT (cdp->diCode), op))
1210 /* save it in our list of items */
1211 addSet (&compItems, IC_RESULT (cdp->diCode));
1213 /* also check for those computed from our computed
1214 list . This will take care of situations like
1215 iTemp1 = iTemp0 + 8;
1216 iTemp2 = iTemp1 + 8; */
1217 if (isinSetWith (compItems, (void*)IC_LEFT (cdp->diCode),
1218 (insetwithFunc)isOperandEqual) ||
1219 isinSetWith (compItems, (void*)IC_RIGHT (cdp->diCode),
1220 (insetwithFunc)isOperandEqual))
1222 addSet (&compItems, IC_RESULT (cdp->diCode));
1227 /* now delete all pointer gets with this op */
1228 deleteItemIf (cseSet, ifPointerGet, op);
1229 deleteItemIf (pss, ifPointerSet, op);
1231 /* set the bit vector used by dataFlow computation later */
1232 ebb->ptrsSet = bitVectSetBit (ebb->ptrsSet, op->key);
1233 /* now for the computed items */
1234 for (cop = setFirstItem (compItems); cop; cop = setNextItem (compItems))
1236 ebb->ptrsSet = bitVectSetBit (ebb->ptrsSet, cop->key);
1237 deleteItemIf (cseSet, ifPointerGet, cop);
1238 deleteItemIf (pss, ifPointerSet, cop);
1242 /*-----------------------------------------------------------------*/
1243 /* delGetPointerSucc - delete get pointer from inExprs of succ with */
1244 /* dfnum > supplied */
1245 /*-----------------------------------------------------------------*/
1246 DEFSETFUNC (delGetPointerSucc)
1248 eBBlock *ebp = item;
1249 V_ARG (operand *, op);
1256 if (ebp->dfnum > dfnum)
1258 deleteItemIf (&ebp->inExprs, ifPointerGet, op);
1261 return applyToSet (ebp->succList, delGetPointerSucc, op, dfnum);
1264 /*-----------------------------------------------------------------*/
1265 /* fixUpTypes - KLUGE HACK fixup a lowering problem */
1266 /*-----------------------------------------------------------------*/
1268 fixUpTypes (iCode * ic)
1270 sym_link *t1 = operandType (IC_LEFT (ic)), *t2;
1272 /* if (TARGET_IS_DS390) */
1273 if (options.model == MODEL_FLAT24)
1279 /* for pointer_gets if the types of result & left r the
1280 same then change it type of result to next */
1282 compareType (t2 = operandType (IC_RESULT (ic)), t1) == 1)
1284 setOperandType (IC_RESULT (ic), t2->next);
1288 /*-----------------------------------------------------------------*/
1289 /* isSignedOp - will return 1 if sign is important to operation */
1290 /*-----------------------------------------------------------------*/
1291 static int isSignedOp (iCode *ic)
1312 case GET_VALUE_AT_ADDRESS:
1337 /*-----------------------------------------------------------------*/
1338 /* cseBBlock - common subexpression elimination for basic blocks */
1339 /* this is the hackiest kludgiest routine in the whole */
1340 /* system. also the most important, since almost all */
1341 /* data flow related information is computed by it */
1342 /*-----------------------------------------------------------------*/
1344 cseBBlock (eBBlock * ebb, int computeOnly,
1345 eBBlock ** ebbs, int count)
1351 set *ptrSetSet = NULL;
1353 /* if this block is not reachable */
1357 /* set of common subexpressions */
1358 cseSet = setFromSet (ebb->inExprs);
1360 /* these will be computed by this routine */
1361 setToNull ((void **) &ebb->outDefs);
1362 setToNull ((void **) &ebb->defSet);
1363 setToNull ((void **) &ebb->usesDefs);
1364 setToNull ((void **) &ebb->ptrsSet);
1365 setToNull ((void **) &ebb->addrOf);
1366 setToNull ((void **) &ebb->ldefs);
1368 ebb->outDefs = bitVectCopy (ebb->inDefs);
1369 bitVectDefault = iCodeKey;
1370 ebb->defSet = newBitVect (iCodeKey);
1371 ebb->usesDefs = newBitVect (iCodeKey);
1373 /* for all the instructions in this block do */
1374 for (ic = ebb->sch; ic; ic = ic->next)
1382 ic->eBBlockNum = ebb->bbnum;
1387 /* if this is an assignment from true symbol
1388 to a temp then do pointer post inc/dec optimzation */
1389 if (ic->op == '=' && !POINTER_SET (ic) &&
1390 IS_PTR (operandType (IC_RESULT (ic))))
1392 ptrPostIncDecOpt (ic);
1395 /* clear the def & use chains for the operands involved */
1396 /* in this operation . since it can change due to opts */
1397 unsetDefsAndUses (ic);
1399 if (ic->op == PCALL || ic->op == CALL || ic->op == RECEIVE)
1401 /* add to defSet of the symbol */
1402 OP_DEFS_SET ((IC_RESULT (ic)),
1403 bitVectSetBit (OP_DEFS (IC_RESULT (ic)), ic->key));
1404 /* add to the definition set of this block */
1405 ebb->defSet = bitVectSetBit (ebb->defSet, ic->key);
1406 ebb->ldefs = bitVectSetBit (ebb->ldefs, ic->key);
1407 ebb->outDefs = bitVectCplAnd (ebb->outDefs, OP_DEFS (IC_RESULT (ic)));
1408 setUsesDefs (IC_RESULT (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
1409 /* delete global variables from the cseSet
1410 since they can be modified by the function call */
1411 deleteItemIf (&cseSet, ifDefGlobal);
1413 /* and also itemps assigned from globals */
1414 deleteItemIf (&cseSet, ifAssignedFromGlobal);
1416 /* delete all getpointer iCodes from cseSet, this should
1417 be done only for global arrays & pointers but at this
1418 point we don't know if globals, so to be safe do all */
1419 deleteItemIf (&cseSet, ifAnyGetPointer);
1422 /* for pcall & ipush we need to add to the useSet */
1423 if ((ic->op == PCALL ||
1427 IS_SYMOP (IC_LEFT (ic)))
1430 /* check if they can be replaced */
1434 applyToSetFTrue (cseSet, findCheaperOp, IC_LEFT (ic), &pdop, 0);
1436 IC_LEFT (ic) = pdop;
1438 /* the lookup could have changed it */
1439 if (IS_SYMOP (IC_LEFT (ic)))
1441 OP_USES_SET ((IC_LEFT (ic)),
1442 bitVectSetBit (OP_USES (IC_LEFT (ic)), ic->key));
1443 setUsesDefs (IC_LEFT (ic), ebb->defSet,
1444 ebb->outDefs, &ebb->usesDefs);
1448 /* if we a sending a pointer as a parameter
1449 then kill all cse since the pointed to item
1450 might be changed in the function being called */
1451 if ((ic->op == IPUSH || ic->op == SEND) &&
1452 IS_PTR (operandType (IC_LEFT (ic))))
1454 deleteGetPointers (&cseSet, &ptrSetSet, IC_LEFT (ic), ebb);
1455 ebb->ptrsSet = bitVectSetBit (ebb->ptrsSet, IC_LEFT (ic)->key);
1456 for (i = 0; i < count; ebbs[i++]->visited = 0);
1457 applyToSet (ebb->succList, delGetPointerSucc,
1458 IC_LEFT (ic), ebb->dfnum);
1463 /* if jumptable then mark the usage */
1464 if (ic->op == JUMPTABLE)
1466 OP_USES_SET ((IC_JTCOND (ic)),
1467 bitVectSetBit (OP_USES (IC_JTCOND (ic)), ic->key));
1468 setUsesDefs (IC_JTCOND (ic), ebb->defSet,
1469 ebb->outDefs, &ebb->usesDefs);
1476 /* do some algebraic optimizations if possible */
1478 while (constFold (ic, cseSet));
1481 if (POINTER_GET (ic) && !IS_PTR (operandType (IC_LEFT (ic))))
1483 setOperandType (IC_LEFT (ic),
1484 aggrToPtr (operandType (IC_LEFT (ic)), FALSE));
1488 if (POINTER_SET (ic) && !IS_PTR (operandType (IC_RESULT (ic))))
1490 setOperandType (IC_RESULT (ic),
1491 aggrToPtr (operandType (IC_RESULT (ic)), FALSE));
1494 /* if this is a condition statment then */
1495 /* check if the condition can be replaced */
1498 ifxOptimize (ic, cseSet, computeOnly,
1504 /* if the assignment & result is a temp */
1505 /* see if we can replace it */
1509 /* update the spill location for this */
1510 updateSpillLocation (ic,0);
1512 if (POINTER_SET (ic) &&
1513 !(IS_BITFIELD (OP_SYMBOL (IC_RESULT (ic))->etype)))
1516 applyToSetFTrue (cseSet, findCheaperOp, IC_RESULT (ic), &pdop, 0);
1517 if (pdop && IS_ITEMP (pdop) && !computeOnly)
1518 IC_RESULT (ic) = pdop;
1522 checkSign = isSignedOp(ic);
1524 /* do the operand lookup i.e. for both the */
1525 /* right & left operand : check the cseSet */
1526 /* to see if they have been replaced if yes */
1527 /* then replace them with those from cseSet */
1529 /* and left is a symbol */
1530 if (IS_SYMOP (IC_LEFT (ic)) &&
1531 !computeOnly && ic->op != ADDRESS_OF)
1535 applyToSetFTrue (cseSet, findCheaperOp, IC_LEFT (ic), &pdop, checkSign);
1538 if (POINTER_GET (ic))
1540 if (IS_ITEMP (pdop) || IS_OP_LITERAL (pdop))
1542 /* some non dominating block does POINTER_SET with
1543 this variable .. unsafe to remove any POINTER_GETs */
1544 if (bitVectBitValue(ebb->ndompset,IC_LEFT(ic)->key))
1545 ebb->ptrsSet = bitVectSetBit(ebb->ptrsSet,pdop->key);
1546 IC_LEFT (ic) = pdop;
1549 /* check if there is a pointer set
1550 for the same pointer visible if yes
1551 then change this into an assignment */
1553 if (applyToSetFTrue (cseSet, findPointerSet, IC_LEFT (ic), &pdop, IC_RESULT (ic)) &&
1554 !bitVectBitValue (ebb->ptrsSet, pdop->key))
1557 IC_LEFT (ic) = NULL;
1558 IC_RIGHT (ic) = pdop;
1559 SET_ISADDR (IC_RESULT (ic), 0);
1565 IC_LEFT (ic) = pdop;
1572 if (IS_SYMOP (IC_RIGHT (ic)) && !computeOnly)
1576 applyToSetFTrue (cseSet, findCheaperOp, IC_RIGHT (ic), &pdop, checkSign);
1579 IC_RIGHT (ic) = pdop;
1584 /* if left or right changed then do algebraic */
1588 while (constFold (ic, cseSet));
1591 /* if after all this it becomes a assignment to self
1592 then delete it and continue */
1593 if (ASSIGNMENT_TO_SELF (ic) && !OTHERS_PARM(OP_SYMBOL(IC_RESULT(ic))))
1595 remiCodeFromeBBlock (ebb, ic);
1599 /* now we will check to see if the entire */
1600 /* operation has been performed before */
1601 /* and is available */
1602 /* don't do assignments they will be killed */
1603 /* by dead code elimination if required do */
1604 /* it only if result is a temporary */
1606 if (!(POINTER_GET (ic) &&
1607 (IS_BITFIELD (OP_SYMBOL (IC_RESULT (ic))->etype) ||
1608 isOperandVolatile (IC_LEFT (ic), TRUE) ||
1609 bitVectBitValue (ebb->ndompset, IC_LEFT (ic)->key))) &&
1611 IS_ITEMP (IC_RESULT (ic)) &&
1614 applyToSet (cseSet, findPrevIc, ic, &pdic);
1615 if (pdic && compareType (operandType (IC_RESULT (pdic)),
1616 operandType (IC_RESULT (ic))) != 1)
1618 if (pdic && port->cseOk && (*port->cseOk)(ic,pdic) == 0)
1622 /* Alternate code */
1623 if (pdic && IS_ITEMP(IC_RESULT(ic))) {
1624 if (POINTER_GET(ic) && bitVectBitValue(ebb->ptrsSet,IC_LEFT(ic)->key)) {
1625 /* Mmm, found an equivalent pointer get at a lower level.
1626 This could be a loop however with the same pointer set
1629 /* if previous definition found change this to an assignment */
1632 IC_RIGHT(ic) = operandFromOperand(IC_RESULT(pdic));
1633 SET_ISADDR(IC_RESULT(ic),0);
1634 SET_ISADDR(IC_RIGHT (ic),0);
1638 if (!(POINTER_SET (ic)) && IC_RESULT (ic)) {
1639 deleteItemIf (&cseSet, ifDefSymIsX, IC_RESULT (ic));
1640 addSetHead (&cseSet, newCseDef (IC_RESULT (ic), ic));
1644 /* if assignment to a parameter which is not
1645 mine and type is a pointer then delete
1646 pointerGets to take care of aliasing */
1647 if (ASSIGNMENT (ic) &&
1648 OTHERS_PARM (OP_SYMBOL (IC_RESULT (ic))) &&
1649 IS_PTR (operandType (IC_RESULT (ic))))
1651 deleteGetPointers (&cseSet, &ptrSetSet, IC_RIGHT (ic), ebb);
1652 for (i = 0; i < count; ebbs[i++]->visited = 0);
1653 applyToSet (ebb->succList, delGetPointerSucc, IC_RIGHT (ic), ebb->dfnum);
1654 ebb->ptrsSet = bitVectSetBit (ebb->ptrsSet, IC_RIGHT (ic)->key);
1657 /* if this is a pointerget then see if we can replace
1658 this with a previously assigned pointer value */
1659 if (POINTER_GET (ic) &&
1660 !(IS_BITFIELD (OP_SYMBOL (IC_RESULT (ic))->etype) ||
1661 isOperandVolatile (IC_LEFT (ic), TRUE)))
1664 applyToSet (ptrSetSet, findPointerSet, IC_LEFT (ic), &pdop, IC_RESULT (ic));
1665 /* if we find it then locally replace all
1666 references to the result with what we assigned */
1669 replaceAllSymBySym (ic->next, IC_RESULT (ic), pdop, &ebb->ndompset);
1673 /* delete from the cseSet anything that has */
1674 /* operands matching the result of this */
1675 /* except in case of pointer access */
1676 if (!(POINTER_SET (ic)) && IC_RESULT (ic))
1678 deleteItemIf (&cseSet, ifOperandsHave, IC_RESULT (ic));
1679 /* delete any previous definitions */
1680 ebb->defSet = bitVectCplAnd (ebb->defSet, OP_DEFS (IC_RESULT (ic)));
1684 /* add the left & right to the defUse set */
1685 if (IC_LEFT (ic) && IS_SYMOP (IC_LEFT (ic)))
1687 OP_USES_SET ((IC_LEFT (ic)),
1688 bitVectSetBit (OP_USES (IC_LEFT (ic)), ic->key));
1689 setUsesDefs (IC_LEFT (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
1693 if (IC_RIGHT (ic) && IS_SYMOP (IC_RIGHT (ic)))
1695 OP_USES_SET ((IC_RIGHT (ic)),
1696 bitVectSetBit (OP_USES (IC_RIGHT (ic)), ic->key));
1697 setUsesDefs (IC_RIGHT (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
1701 /* for the result it is special case, put the result */
1702 /* in the defuseSet if it a pointer or array access */
1703 if (POINTER_SET (defic))
1705 OP_USES_SET ((IC_RESULT (ic)),
1706 bitVectSetBit (OP_USES (IC_RESULT (ic)), ic->key));
1707 setUsesDefs (IC_RESULT (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
1708 deleteItemIf (&cseSet, ifPointerGet, IC_RESULT (ic));
1709 ebb->ptrsSet = bitVectSetBit (ebb->ptrsSet, IC_RESULT (ic)->key);
1710 /* delete from inexpressions of all successors which
1711 have dfNum > than this block */
1712 for (i = 0; i < count; ebbs[i++]->visited = 0);
1713 applyToSet (ebb->succList, delGetPointerSucc, IC_RESULT (ic), ebb->dfnum);
1715 /* delete from cseSet all other pointer sets
1717 deleteItemIf (&ptrSetSet, ifPointerSet, IC_RESULT (ic));
1718 /* add to the local pointerset set */
1719 addSetHead (&ptrSetSet, newCseDef (IC_RESULT (ic), ic));
1722 /* add the result to defintion set */ if (IC_RESULT (ic))
1724 OP_DEFS_SET ((IC_RESULT (ic)),
1725 bitVectSetBit (OP_DEFS (IC_RESULT (ic)), ic->key));
1726 ebb->defSet = bitVectSetBit (ebb->defSet, ic->key);
1727 ebb->outDefs = bitVectCplAnd (ebb->outDefs, OP_DEFS (IC_RESULT (ic)));
1728 ebb->ldefs = bitVectSetBit (ebb->ldefs, ic->key);
1732 /* if this is an addressof instruction then */
1733 /* put the symbol in the address of list & */
1734 /* delete it from the cseSet */
1735 if (defic->op == ADDRESS_OF)
1737 addSetHead (&ebb->addrOf, IC_LEFT (ic));
1738 deleteItemIf (&cseSet, ifDefSymIsX, IC_LEFT (ic));
1742 setToNull ((void **) &ebb->outExprs);
1743 ebb->outExprs = cseSet;
1744 ebb->outDefs = bitVectUnion (ebb->outDefs, ebb->defSet);
1745 ebb->ptrsSet = bitVectUnion (ebb->ptrsSet, ebb->inPtrsSet);
1749 /*-----------------------------------------------------------------*/
1750 /* cseAllBlocks - will sequentially go thru & do cse for all blocks */
1751 /*-----------------------------------------------------------------*/
1753 cseAllBlocks (eBBlock ** ebbs, int count)
1758 /* if optimization turned off */
1760 for (i = 0; i < count; i++)
1761 change += cseBBlock (ebbs[i], FALSE, ebbs, count);