1 //#define LIVERANGEHUNT
7 /*-------------------------------------------------------------------------
8 SDCCcse.c - source file for Common Subexpressions and other utility
10 Written By - Sandeep Dutta . sandeep.dutta@usa.net (1998)
12 This program is free software; you can redistribute it and/or modify it
13 under the terms of the GNU General Public License as published by the
14 Free Software Foundation; either version 2, or (at your option) any
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
26 In other words, you are welcome to use, share and improve this program.
27 You are forbidden to forbid anyone else to use, share and improve
28 what you give them. Help stamp out software-hoarding!
29 -------------------------------------------------------------------------*/
34 /*-----------------------------------------------------------------*/
35 /* newCseDef - new cseDef */
36 /*-----------------------------------------------------------------*/
38 newCseDef (operand * sym, iCode * ic)
43 cdp = Safe_alloc (sizeof (cseDef));
54 /*-----------------------------------------------------------------*/
55 /* int isCseDefEqual - two definitions are equal */
56 /*-----------------------------------------------------------------*/
58 isCseDefEqual (void *vsrc, void *vdest)
66 return (src->key == dest->key &&
67 src->diCode == dest->diCode);
71 /*-----------------------------------------------------------------*/
72 /* pcseDef - in the cseDef */
73 /*-----------------------------------------------------------------*/
75 pcseDef (void *item, va_list ap)
83 fprintf (stdout, "**null op**");
84 printOperand (cdp->sym, stdout);
85 icTab = getTableEntry (cdp->diCode->op);
86 icTab->iCodePrint (stdout, cdp->diCode, icTab->printName);
90 void ReplaceOpWithCheaperOp(operand **op, operand *cop) {
92 printf ("ReplaceOpWithCheaperOp (%s:%d with %s:%d): ",
93 OP_SYMBOL((*op))->name, OP_SYMBOL((*op))->isreqv,
94 OP_SYMBOL(cop)->name, OP_SYMBOL(cop)->isreqv);
95 // if op is a register equivalent
96 if (IS_ITEMP(cop) && OP_SYMBOL((*op))->isreqv) {
97 operand **rop = &OP_SYMBOL((*op))->usl.spillLoc->reqv;
98 if (isOperandEqual(*rop, *op)) {
101 OP_SYMBOL((*op))->isreqv=0;
102 OP_SYMBOL(cop)->isreqv=1;
112 /*-----------------------------------------------------------------*/
113 /* replaceAllSymBySym - replaces all operands by operand in an */
114 /* instruction chain */
115 /*-----------------------------------------------------------------*/
117 replaceAllSymBySym (iCode * ic, operand * from, operand * to, bitVect ** ndpset)
121 LRH(printf ("replaceAllSymBySym: from %s to %s\n", OP_SYMBOL(from)->name, OP_SYMBOL(to)->name));
122 for (lic = ic; lic; lic = lic->next)
126 /* do the special cases first */
130 IC_COND (lic)->key == from->key)
133 bitVectUnSetBit (OP_USES (from), lic->key);
134 OP_USES(to)=bitVectSetBit (OP_USES (to), lic->key);
135 siaddr = IC_COND (lic)->isaddr;
136 IC_COND (lic) = operandFromOperand (to);
137 IC_COND (lic)->isaddr = siaddr;
143 if (lic->op == JUMPTABLE)
146 IC_JTCOND (lic)->key == from->key)
149 bitVectUnSetBit (OP_USES (from), lic->key);
150 OP_USES(to)=bitVectSetBit (OP_USES (to), lic->key);
151 siaddr = IC_COND (lic)->isaddr;
152 IC_JTCOND (lic) = operandFromOperand (to);
153 IC_JTCOND (lic)->isaddr = siaddr;
159 if (IC_RESULT (lic) && IC_RESULT (lic)->key == from->key)
161 /* maintain du chains */
162 if (POINTER_SET (lic))
164 bitVectUnSetBit (OP_USES (from), lic->key);
165 OP_USES(to)=bitVectSetBit (OP_USES (to), lic->key);
167 /* also check if the "from" was in the non-dominating
168 pointer sets and replace it with "to" in the bitVector */
169 if (bitVectBitValue (*ndpset, from->key))
171 bitVectUnSetBit (*ndpset, from->key);
172 bitVectSetBit (*ndpset, to->key);
178 bitVectUnSetBit (OP_DEFS (from), lic->key);
179 OP_DEFS(to)=bitVectSetBit (OP_DEFS (to), lic->key);
181 siaddr = IC_RESULT (lic)->isaddr;
182 IC_RESULT (lic) = operandFromOperand (to);
183 IC_RESULT (lic)->isaddr = siaddr;
187 IC_RIGHT (lic) && IC_RIGHT (lic)->key == from->key)
189 bitVectUnSetBit (OP_USES (from), lic->key);
190 OP_USES(to)=bitVectSetBit (OP_USES (to), lic->key);
191 siaddr = IC_RIGHT (lic)->isaddr;
192 IC_RIGHT (lic) = operandFromOperand (to);
193 IC_RIGHT (lic)->isaddr = siaddr;
197 IC_LEFT (lic) && IC_LEFT (lic)->key == from->key)
199 bitVectUnSetBit (OP_USES (from), lic->key);
200 OP_USES(to)=bitVectSetBit (OP_USES (to), lic->key);
201 siaddr = IC_LEFT (lic)->isaddr;
202 IC_LEFT (lic) = operandFromOperand (to);
203 IC_LEFT (lic)->isaddr = siaddr;
208 /*-----------------------------------------------------------------*/
209 /* iCodeKeyIs - if the icode keys match then return 1 */
210 /*-----------------------------------------------------------------*/
211 DEFSETFUNC (iCodeKeyIs)
216 if (cdp->diCode->key == key)
222 /*-----------------------------------------------------------------*/
223 /* removeFromInExprs - removes an icode from inexpressions */
224 /*-----------------------------------------------------------------*/
225 DEFSETFUNC (removeFromInExprs)
229 V_ARG (operand *, from);
230 V_ARG (operand *, to);
231 V_ARG (eBBlock *, cbp);
237 deleteItemIf (&ebp->inExprs, iCodeKeyIs, ic->key);
238 if (ebp != cbp && !bitVectBitValue (cbp->domVect, ebp->bbnum))
239 replaceAllSymBySym (ebp->sch, from, to, &ebp->ndompset);
241 applyToSet (ebp->succList, removeFromInExprs, ic, from, to, cbp);
245 /*-----------------------------------------------------------------*/
246 /* isGlobalInNearSpace - return TRUE if valriable is a globalin data */
247 /*-----------------------------------------------------------------*/
249 isGlobalInNearSpace (operand * op)
251 sym_link *type = getSpec (operandType (op));
252 /* this is 8051 specific: optimization
253 suggested by Jean-Louis VERN, with 8051s we have no
254 advantage of putting variables in near space into
256 if (isOperandGlobal (op) && !IN_FARSPACE (SPEC_OCLS (type)) &&
257 IN_DIRSPACE (SPEC_OCLS (type)))
263 /*-----------------------------------------------------------------*/
264 /* findCheaperOp - cseBBlock support routine, will check to see if */
265 /* we have a operand previously defined */
266 /*-----------------------------------------------------------------*/
267 DEFSETFUNC (findCheaperOp)
270 V_ARG (operand *, cop);
271 V_ARG (operand **, opp);
272 V_ARG (int, checkSign);
274 /* if we have already found it */
278 /* not found it yet check if this is the one */
279 /* and this is not the defining one */
280 if (cop->key == cdp->key)
283 /* do a special check this will help in */
284 /* constant propagation & dead code elim */
285 /* for assignments only */
286 if (cdp->diCode->op == '=') {
287 /* if the result is volatile then return result */
288 if (IS_OP_VOLATILE (IC_RESULT (cdp->diCode)))
289 *opp = IC_RESULT (cdp->diCode);
291 /* if this is a straight assignment and
292 left is a temp then prefer the temporary to the
294 if (!POINTER_SET (cdp->diCode) &&
295 IS_ITEMP (IC_RESULT (cdp->diCode)) &&
296 IS_TRUE_SYMOP (IC_RIGHT (cdp->diCode)))
297 *opp = IC_RESULT (cdp->diCode);
299 /* if straight assignement && and both
300 are temps then prefer the one that
301 will not need extra space to spil, also
302 take into consideration if right side
303 an induction variable
305 if (!POINTER_SET (cdp->diCode) &&
306 IS_ITEMP (IC_RESULT (cdp->diCode)) &&
307 IS_ITEMP (IC_RIGHT (cdp->diCode)) &&
308 !OP_SYMBOL (IC_RIGHT (cdp->diCode))->isind &&
309 !OP_SYMBOL(IC_RIGHT (cdp->diCode))->isreqv &&
310 ((!SPIL_LOC (IC_RIGHT (cdp->diCode)) &&
311 SPIL_LOC (IC_RESULT (cdp->diCode))) ||
312 (SPIL_LOC (IC_RESULT (cdp->diCode)) &&
313 SPIL_LOC (IC_RESULT (cdp->diCode)) ==
314 SPIL_LOC (IC_RIGHT (cdp->diCode)))))
315 *opp = IC_RESULT (cdp->diCode);
317 *opp = IC_RIGHT (cdp->diCode);
321 *opp = IC_RESULT (cdp->diCode);
324 /* if this is an assign to a temp. then check
325 if the right side is this then return this */
326 if (IS_TRUE_SYMOP (cop) &&
327 cdp->diCode->op == '=' &&
328 !POINTER_SET (cdp->diCode) &&
329 cop->key == IC_RIGHT (cdp->diCode)->key &&
330 !isGlobalInNearSpace (IC_RIGHT (cdp->diCode)) &&
331 IS_ITEMP (IC_RESULT (cdp->diCode)))
332 *opp = IC_RESULT (cdp->diCode);
335 (isOperandLiteral(*opp) || !checkSign ||
337 (SPEC_USIGN(operandType (cop))==SPEC_USIGN(operandType (*opp)) &&
338 (SPEC_LONG(operandType (cop))==SPEC_LONG(operandType (*opp)))))))
341 if ((isGlobalInNearSpace (cop) &&
342 !isOperandLiteral (*opp)) ||
343 isOperandVolatile (*opp, FALSE)
350 if (cop->key == (*opp)->key)
356 if ((*opp)->isaddr != cop->isaddr && IS_ITEMP (cop))
358 *opp = operandFromOperand (*opp);
359 (*opp)->isaddr = cop->isaddr;
361 LRH(printf ("findCheaperOp: %s < %s\n",\
362 IS_SYMOP((*opp)) ? OP_SYMBOL((*opp))->name : "!SYM",\
363 OP_SYMBOL(cop)->name));
371 /*-----------------------------------------------------------------*/
372 /* findPointerSet - finds the right side of a pointer set op */
373 /*-----------------------------------------------------------------*/
374 DEFSETFUNC (findPointerSet)
377 V_ARG (operand *, op);
378 V_ARG (operand **, opp);
379 V_ARG (operand *, rop);
381 if (POINTER_SET (cdp->diCode) &&
382 IC_RESULT (cdp->diCode)->key == op->key &&
383 !isOperandVolatile (IC_RESULT (cdp->diCode), TRUE) &&
384 !isOperandVolatile (IC_RIGHT (cdp->diCode), TRUE) &&
385 getSize (operandType (IC_RIGHT (cdp->diCode))) ==
386 getSize (operandType (rop)))
388 *opp = IC_RIGHT (cdp->diCode);
395 /*-----------------------------------------------------------------*/
396 /* findPrevIc - cseBBlock support function will return the iCode */
397 /* which matches the current one */
398 /*-----------------------------------------------------------------*/
399 DEFSETFUNC (findPrevIc)
403 V_ARG (iCode **, icp);
405 /* if already found */
409 /* if the iCodes are the same */
410 if (isiCodeEqual (ic, cdp->diCode) &&
411 isOperandEqual (cdp->sym, IC_RESULT (cdp->diCode)))
413 LRH(printf ("findPrevIc same: %d %d\n", ic->key, cdp->diCode->key));
418 /* if iCodes are not the same */
419 /* see the operands maybe interchanged */
420 if (ic->op == cdp->diCode->op &&
421 (ic->op == '+' || ic->op == '*') &&
422 isOperandEqual (IC_LEFT (ic), IC_RIGHT (cdp->diCode)) &&
423 isOperandEqual (IC_RIGHT (ic), IC_LEFT (cdp->diCode)))
425 LRH(printf ("findPrevIc inter: %d %d\n", ic->key, cdp->diCode->key));
433 /*-------------------------------------------------------------------*/
434 /* ifAssignedFromGlobal - if definition is an assignment from global */
435 /*-------------------------------------------------------------------*/
436 DEFSETFUNC (ifAssignedFromGlobal)
439 iCode *dic=cdp->diCode;
441 if (dic->op=='=' && isOperandGlobal(IC_RIGHT(dic))) {
447 /*-----------------------------------------------------------------*/
448 /* ifDefGlobal - if definition is global */
449 /*-----------------------------------------------------------------*/
450 DEFSETFUNC (ifDefGlobal)
454 return (isOperandGlobal (cdp->sym));
457 /*-----------------------------------------------------------------*/
458 /* ifAnyGetPointer - if get pointer icode */
459 /*-----------------------------------------------------------------*/
460 DEFSETFUNC (ifAnyGetPointer)
464 if (cdp->diCode && POINTER_GET (cdp->diCode))
469 /*-----------------------------------------------------------------*/
470 /* ifOperandsHave - if any of the operand are the same as this */
471 /*-----------------------------------------------------------------*/
472 DEFSETFUNC (ifOperandsHave)
475 V_ARG (operand *, op);
478 if (IC_LEFT (cdp->diCode) &&
479 IS_SYMOP (IC_LEFT (cdp->diCode)) &&
480 IC_LEFT (cdp->diCode)->key == op->key)
483 if (IC_RIGHT (cdp->diCode) &&
484 IS_SYMOP (IC_RIGHT (cdp->diCode)) &&
485 IC_RIGHT (cdp->diCode)->key == op->key)
488 /* or if any of the operands are volatile */
489 if (IC_LEFT (cdp->diCode) &&
490 IS_OP_VOLATILE (IC_LEFT (cdp->diCode)))
493 if (IC_RIGHT (cdp->diCode) &&
494 IS_OP_VOLATILE (IC_RIGHT (cdp->diCode)))
498 if (IC_RESULT (cdp->diCode) &&
499 IS_OP_VOLATILE (IC_RESULT (cdp->diCode)))
505 /*-----------------------------------------------------------------*/
506 /* ifDefSymIs - if a definition is found in the set */
507 /*-----------------------------------------------------------------*/
509 ifDefSymIs (set * cseSet, operand * sym)
514 if (!sym || !IS_SYMOP (sym))
516 for (sl = cseSet; sl; sl = sl->next)
519 if (loop->sym->key == sym->key)
526 /*-----------------------------------------------------------------*/
527 /* ifDefSymIsX - will return 1 if the symbols match */
528 /*-----------------------------------------------------------------*/
529 DEFSETFUNC (ifDefSymIsX)
532 V_ARG (operand *, op);
535 return cdp->sym->key == op->key;
537 return (isOperandEqual (cdp->sym, op));
542 /*-----------------------------------------------------------------*/
543 /* ifDiCodeIs - returns truw if diCode is same */
544 /*-----------------------------------------------------------------*/
546 ifDiCodeIs (set * cseSet, iCode * ic)
554 for (sl = cseSet; sl; sl = sl->next)
557 if (loop->diCode == ic)
564 /*-----------------------------------------------------------------*/
565 /* ifPointerGet - returns true if the icode is pointer get sym */
566 /*-----------------------------------------------------------------*/
567 DEFSETFUNC (ifPointerGet)
570 V_ARG (operand *, op);
571 iCode *dic = cdp->diCode;
572 operand *left = IC_LEFT (cdp->diCode);
574 if (POINTER_GET (dic) && left->key == op->key)
580 /*-----------------------------------------------------------------*/
581 /* ifPointerSet - returns true if the icode is pointer set sym */
582 /*-----------------------------------------------------------------*/
583 DEFSETFUNC (ifPointerSet)
586 V_ARG (operand *, op);
588 if (POINTER_SET (cdp->diCode) &&
589 IC_RESULT (cdp->diCode)->key == op->key)
595 /*-----------------------------------------------------------------*/
596 /* ifDiCodeIsX - will return 1 if the symbols match */
597 /*-----------------------------------------------------------------*/
598 DEFSETFUNC (ifDiCodeIsX)
603 return cdp->diCode == ic;
607 /*-----------------------------------------------------------------*/
608 /* findBackwardDef - scan backwards to find deinition of operand */
609 /*-----------------------------------------------------------------*/
610 iCode *findBackwardDef(operand *op,iCode *ic)
614 for (lic = ic; lic ; lic = lic->prev) {
615 if (IC_RESULT(lic) && isOperandEqual(op,IC_RESULT(lic)))
621 /*-----------------------------------------------------------------*/
622 /* algebraicOpts - does some algebraic optimizations */
623 /*-----------------------------------------------------------------*/
625 algebraicOpts (iCode * ic)
627 /* we don't deal with the following iCodes
638 /* if both operands present & ! IFX */
639 /* then if they are both literal we */
640 /* perform the operation right now */
641 if (IC_RESULT (ic) &&
644 IS_OP_LITERAL (IC_LEFT (ic)) &&
645 IS_OP_LITERAL (IC_RIGHT (ic)))
648 IC_RIGHT (ic) = operandOperation (IC_LEFT (ic),
651 operandType (IC_RESULT (ic)));
654 SET_RESULT_RIGHT (ic);
658 /* if not ifx & only one operand present */
659 if (IC_RESULT (ic) &&
661 IS_OP_LITERAL (IC_LEFT (ic)) &&
665 IC_RIGHT (ic) = operandOperation (IC_LEFT (ic),
668 operandType (IC_RESULT (ic)));
671 SET_RESULT_RIGHT (ic);
676 /* a special case : or in short a kludgy solution will think
677 about a better solution over a glass of wine someday */
678 if (ic->op == GET_VALUE_AT_ADDRESS)
681 if (IS_ITEMP (IC_RESULT (ic)) &&
682 IS_TRUE_SYMOP (IC_LEFT (ic)))
686 IC_RIGHT (ic) = operandFromOperand (IC_LEFT (ic));
687 IC_RIGHT (ic)->isaddr = 0;
689 IC_RESULT (ic) = operandFromOperand (IC_RESULT (ic));
690 IC_RESULT (ic)->isaddr = 0;
691 setOperandType (IC_RESULT (ic), operandType (IC_RIGHT (ic)));
695 if (IS_ITEMP (IC_LEFT (ic)) &&
696 IS_ITEMP (IC_RESULT (ic)) &&
697 /* !OP_SYMBOL(IC_RESULT(ic))->isreqv && */
698 /* !OP_SYMBOL(IC_LEFT(ic))->isreqv && */
699 !IC_LEFT (ic)->isaddr)
702 IC_RIGHT (ic) = operandFromOperand (IC_LEFT (ic));
703 IC_RIGHT (ic)->isaddr = 0;
704 IC_RESULT (ic) = operandFromOperand (IC_RESULT (ic));
705 IC_RESULT (ic)->isaddr = 0;
713 /* depending on the operation */
717 /* if adding the same thing change to left shift by 1 */
718 if (IC_LEFT (ic)->key == IC_RIGHT (ic)->key &&
719 !IS_FLOAT (operandType (IC_RESULT (ic))))
722 IC_RIGHT (ic) = operandFromLit (1);
725 /* if addition then check if one of them is a zero */
726 /* if yes turn it into assignmnt */
727 if (IS_OP_LITERAL (IC_LEFT (ic)) &&
728 operandLitValue (IC_LEFT (ic)) == 0.0)
733 SET_ISADDR (IC_RESULT (ic), 0);
734 SET_ISADDR (IC_RIGHT (ic), 0);
737 if (IS_OP_LITERAL (IC_RIGHT (ic)) &&
738 operandLitValue (IC_RIGHT (ic)) == 0.0)
742 IC_RIGHT (ic) = IC_LEFT (ic);
744 SET_ISADDR (IC_RIGHT (ic), 0);
745 SET_ISADDR (IC_RESULT (ic), 0);
750 /* if subtracting the the same thing then zero */
751 if (IC_LEFT (ic)->key == IC_RIGHT (ic)->key)
754 IC_RIGHT (ic) = operandFromLit (0);
756 IC_RESULT (ic) = operandFromOperand (IC_RESULT (ic));
757 IC_RESULT (ic)->isaddr = 0;
761 /* if subtraction then check if one of the operand */
762 /* is zero then depending on which operand change */
763 /* to assignment or unary minus */
764 if (IS_OP_LITERAL (IC_RIGHT (ic)) &&
765 operandLitValue (IC_RIGHT (ic)) == 0.0)
767 /* right size zero change to assignment */
769 IC_RIGHT (ic) = IC_LEFT (ic);
771 SET_ISADDR (IC_RIGHT (ic), 0);
772 SET_ISADDR (IC_RESULT (ic), 0);
775 if (IS_OP_LITERAL (IC_LEFT (ic)) &&
776 operandLitValue (IC_LEFT (ic)) == 0.0)
778 /* left zero turn into an unary minus */
780 IC_LEFT (ic) = IC_RIGHT (ic);
781 IC_RIGHT (ic) = NULL;
785 /* if multiplication then check if either of */
786 /* them is zero then the result is zero */
787 /* if either of them is one then result is */
790 if (IS_OP_LITERAL (IC_LEFT (ic)))
793 if (operandLitValue (IC_LEFT (ic)) == 0.0)
796 IC_RIGHT (ic) = IC_LEFT (ic);
798 SET_RESULT_RIGHT (ic);
801 if (operandLitValue (IC_LEFT (ic)) == 1.0)
805 SET_RESULT_RIGHT (ic);
810 if (IS_OP_LITERAL (IC_RIGHT (ic)))
813 if (operandLitValue (IC_RIGHT (ic)) == 0.0)
817 SET_RESULT_RIGHT (ic);
821 if (operandLitValue (IC_RIGHT (ic)) == 1.0)
824 IC_RIGHT (ic) = IC_LEFT (ic);
826 SET_RESULT_RIGHT (ic);
832 /* if division by self then 1 */
833 if (IC_LEFT (ic)->key == IC_RIGHT (ic)->key)
836 IC_RIGHT (ic) = operandFromLit (1);
838 IC_RESULT (ic) = operandFromOperand (IC_RESULT (ic));
839 IC_RESULT (ic)->isaddr = 0;
842 /* if this is a division then check if right */
843 /* is one then change it to an assignment */
844 if (IS_OP_LITERAL (IC_RIGHT (ic)) &&
845 operandLitValue (IC_RIGHT (ic)) == 1.0)
849 IC_RIGHT (ic) = IC_LEFT (ic);
851 SET_RESULT_RIGHT (ic);
855 /* if both are the same for an comparison operators */
859 if (isOperandEqual (IC_LEFT (ic), IC_RIGHT (ic)))
862 IC_RIGHT (ic) = operandFromLit (1);
864 SET_RESULT_RIGHT (ic);
870 if (isOperandEqual (IC_LEFT (ic), IC_RIGHT (ic)))
873 IC_RIGHT (ic) = operandFromLit (0);
875 SET_RESULT_RIGHT (ic);
880 sym_link *otype = operandType(IC_RIGHT(ic));
881 sym_link *ctype = operandType(IC_LEFT(ic));
882 /* if this is a cast of a literal value */
883 if (IS_OP_LITERAL (IC_RIGHT (ic)) &&
884 !(IS_GENPTR(ctype) && (IS_PTR(otype) && !IS_GENPTR(otype)))) {
887 operandFromValue (valCastLiteral (operandType (IC_LEFT (ic)),
888 operandLitValue (IC_RIGHT (ic))));
890 SET_ISADDR (IC_RESULT (ic), 0);
892 /* if casting to the same */
893 if (compareType (operandType (IC_RESULT (ic)),
894 operandType (IC_RIGHT (ic))) == 1) {
897 SET_ISADDR (IC_RESULT (ic), 0);
902 if (IS_OP_LITERAL (IC_LEFT (ic)))
906 (operandLitValue (IC_LEFT (ic)) == 0 ?
907 operandFromLit (1) : operandFromLit (0));
909 SET_ISADDR (IC_RESULT (ic), 0);
915 #define OTHERS_PARM(s) (s->_isparm && !s->ismyparm)
916 /*-----------------------------------------------------------------*/
917 /* updateSpillLocation - keeps track of register spill location */
918 /*-----------------------------------------------------------------*/
920 updateSpillLocation (iCode * ic, int induction)
924 if (POINTER_SET (ic))
930 /* for the form true_symbol := iTempNN */
931 if (ASSIGN_ITEMP_TO_SYM (ic) &&
932 !SPIL_LOC (IC_RIGHT (ic))) {
934 setype = getSpec (operandType (IC_RESULT (ic)));
936 if (!OP_SYMBOL(IC_RIGHT (ic))->noSpilLoc &&
937 !IS_VOLATILE (setype) &&
938 !IN_FARSPACE (SPEC_OCLS (setype)) &&
939 !OTHERS_PARM (OP_SYMBOL (IC_RESULT (ic))))
941 wassert(IS_SYMOP(IC_RESULT (ic)));
942 wassert(IS_SYMOP(IC_RIGHT (ic)));
943 SPIL_LOC (IC_RIGHT (ic)) =
944 IC_RESULT (ic)->operand.symOperand;
949 #if 0 /* this needs furthur investigation can save a lot of code */
950 if (ASSIGN_SYM_TO_ITEMP(ic) &&
951 !SPIL_LOC(IC_RESULT(ic))) {
952 if (!OTHERS_PARM (OP_SYMBOL (IC_RIGHT (ic))))
953 SPIL_LOC (IC_RESULT (ic)) =
954 IC_RIGHT (ic)->operand.symOperand;
957 if (ASSIGN_ITEMP_TO_ITEMP (ic)) {
959 if (!SPIL_LOC (IC_RIGHT (ic)) &&
960 !bitVectBitsInCommon (OP_DEFS (IC_RIGHT (ic)), OP_USES (IC_RESULT (ic))) &&
961 OP_SYMBOL (IC_RESULT (ic))->isreqv) {
963 setype = getSpec (operandType (IC_RESULT (ic)));
965 if (!OP_SYMBOL(IC_RIGHT (ic))->noSpilLoc &&
966 !IS_VOLATILE (setype) &&
967 !IN_FARSPACE (SPEC_OCLS (setype)) &&
968 !OTHERS_PARM (OP_SYMBOL (IC_RESULT (ic))))
970 SPIL_LOC (IC_RIGHT (ic)) =
971 SPIL_LOC (IC_RESULT (ic));
973 /* special case for inductions */
975 OP_SYMBOL(IC_RIGHT(ic))->isreqv &&
976 !OP_SYMBOL(IC_RESULT (ic))->noSpilLoc &&
977 !SPIL_LOC(IC_RESULT(ic))) {
978 SPIL_LOC (IC_RESULT (ic)) = SPIL_LOC (IC_RIGHT (ic));
982 /*-----------------------------------------------------------------*/
983 /* setUsesDef - sets the uses def bitvector for a given operand */
984 /*-----------------------------------------------------------------*/
986 setUsesDefs (operand * op, bitVect * bdefs,
987 bitVect * idefs, bitVect ** oud)
989 /* compute the definitions alive at this point */
990 bitVect *adefs = bitVectUnion (bdefs, idefs);
992 /* of these definitions find the ones that are */
993 /* for this operand */
994 adefs = bitVectIntersect (adefs, OP_DEFS (op));
996 /* these are the definitions that this operand can use */
997 op->usesDefs = adefs;
999 /* the out defs is an union */
1000 *oud = bitVectUnion (*oud, adefs);
1003 /*-----------------------------------------------------------------*/
1004 /* unsetDefsAndUses - clear this operation for the operands */
1005 /*-----------------------------------------------------------------*/
1007 unsetDefsAndUses (iCode * ic)
1009 if (ic->op == JUMPTABLE)
1012 /* take away this definition from the def chain of the */
1013 /* result & take away from use set of the operands */
1016 /* turn off def set */
1017 if (IS_SYMOP (IC_RESULT (ic)))
1019 if (!POINTER_SET (ic))
1020 bitVectUnSetBit (OP_DEFS (IC_RESULT (ic)), ic->key);
1022 bitVectUnSetBit (OP_USES (IC_RESULT (ic)), ic->key);
1024 /* turn off the useSet for the operands */
1025 if (IS_SYMOP (IC_LEFT (ic)))
1026 bitVectUnSetBit (OP_USES (IC_LEFT (ic)), ic->key);
1028 if (IS_SYMOP (IC_RIGHT (ic)))
1029 bitVectUnSetBit (OP_USES (IC_RIGHT (ic)), ic->key);
1032 /* must be ifx turn off the use */ if (IS_SYMOP (IC_COND (ic)))
1033 bitVectUnSetBit (OP_USES (IC_COND (ic)), ic->key);
1036 /*-----------------------------------------------------------------*/
1037 /* ifxOptimize - changes ifx conditions if it can */
1038 /*-----------------------------------------------------------------*/
1040 ifxOptimize (iCode * ic, set * cseSet,
1042 eBBlock * ebb, int *change,
1043 eBBlock ** ebbs, int count)
1048 /* if the condition can be replaced */
1052 applyToSetFTrue (cseSet, findCheaperOp, IC_COND (ic), &pdop, 0);
1055 ReplaceOpWithCheaperOp(&IC_COND (ic), pdop);
1060 /* if the conditional is a literal then */
1061 if (IS_OP_LITERAL (IC_COND (ic)))
1064 if ((operandLitValue (IC_COND (ic)) != 0.0) && IC_TRUE (ic))
1067 /* change to a goto */
1069 IC_LABEL (ic) = IC_TRUE (ic);
1076 if (!operandLitValue (IC_COND (ic)) && IC_FALSE (ic))
1079 IC_LABEL (ic) = IC_FALSE (ic);
1085 /* then kill this if condition */
1086 remiCodeFromeBBlock (ebb, ic);
1090 /* now we need to recompute the control flow */
1091 /* since the control flow has changed */
1092 /* this is very expensive but it does not happen */
1093 /* too often, if it does happen then the user pays */
1095 computeControlFlow (ebbs, count, 1);
1096 if (!options.lessPedantic) {
1097 werror (W_CONTROL_FLOW, ic->filename, ic->lineno);
1102 /* if there is only one successor and that successor
1103 is the same one we are conditionally going to then
1104 we can remove this conditional statement */
1105 label = (IC_TRUE (ic) ? IC_TRUE (ic) : IC_FALSE (ic));
1106 if (elementsInSet (ebb->succList) == 1 &&
1107 isinSet (ebb->succList, eBBWithEntryLabel (ebbs, label, count)))
1110 remiCodeFromeBBlock (ebb, ic);
1111 computeControlFlow (ebbs, count, 1);
1112 if (!options.lessPedantic) {
1113 werror (W_CONTROL_FLOW, ic->filename, ic->lineno);
1119 /* if it remains an IFX the update the use Set */
1120 OP_USES(IC_COND (ic))=bitVectSetBit (OP_USES (IC_COND (ic)), ic->key);
1121 setUsesDefs (IC_COND (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
1125 /*-----------------------------------------------------------------*/
1126 /* diCodeForSym - finds the definiting instruction for a symbol */
1127 /*-----------------------------------------------------------------*/
1128 DEFSETFUNC (diCodeForSym)
1131 V_ARG (operand *, sym);
1132 V_ARG (iCode **, dic);
1134 /* if already found */
1138 /* if not if this is the defining iCode */
1139 if (sym->key == cdp->key)
1148 /*-----------------------------------------------------------------*/
1149 /* constFold - does some constant folding */
1150 /*-----------------------------------------------------------------*/
1152 constFold (iCode * ic, set * cseSet)
1156 /* this routine will change
1162 /* deal with only + & - */
1163 if (ic->op != '+' &&
1167 /* this check is a hueristic to prevent live ranges
1168 from becoming too long */
1169 if (IS_PTR (operandType (IC_RESULT (ic))))
1172 /* check if operation with a literal */
1173 if (!IS_OP_LITERAL (IC_RIGHT (ic)))
1176 /* check if we can find a definition for the
1178 if (!(applyToSet (cseSet, diCodeForSym, IC_LEFT (ic), &dic)))
1181 /* check that this is also a +/- */
1182 if (dic->op != '+' && dic->op != '-')
1185 /* with a literal */
1186 if (!IS_OP_LITERAL (IC_RIGHT (dic)))
1189 /* find the definition of the left operand
1190 of dic.then check if this defined with a
1191 get_pointer return 0 if the pointer size is
1192 less than 2 (MCS51 specific) */
1193 if (!(applyToSet (cseSet, diCodeForSym, IC_LEFT (dic), &ldic)))
1196 if (POINTER_GET (ldic) && getSize (operandType (IC_LEFT (ldic))) <= 1)
1199 /* it is if the operations are the same */
1200 /* the literal parts need to be added */
1201 IC_LEFT (ic) = operandFromOperand (IC_LEFT (dic));
1202 if (ic->op == dic->op)
1203 IC_RIGHT (ic) = operandFromLit (operandLitValue (IC_RIGHT (ic)) +
1204 operandLitValue (IC_RIGHT (dic)));
1206 IC_RIGHT (ic) = operandFromLit (operandLitValue (IC_RIGHT (ic)) -
1207 operandLitValue (IC_RIGHT (dic)));
1209 if (IS_ITEMP (IC_RESULT (ic)))
1211 SPIL_LOC (IC_RESULT (ic)) = NULL;
1212 OP_SYMBOL(IC_RESULT (ic))->noSpilLoc = 1;
1219 /*-----------------------------------------------------------------*/
1220 /* deleteGetPointers - called when a pointer is passed as parm */
1221 /* will delete from cseSet all get pointers computed from this */
1222 /* pointer. A simple ifOperandsHave is not good enough here */
1223 /*-----------------------------------------------------------------*/
1225 deleteGetPointers (set ** cseSet, set ** pss, operand * op, eBBlock * ebb)
1227 set *compItems = NULL;
1232 if (!*cseSet && !*pss)
1235 /* first find all items computed from this operand .
1236 This done fairly simply go thru the list and find
1237 those that are computed by arthimetic with this
1239 for (cdp = setFirstItem (*cseSet); cdp; cdp = setNextItem (*cseSet))
1241 if (IS_ARITHMETIC_OP (cdp->diCode))
1243 if (isOperandEqual (IC_LEFT (cdp->diCode), op) ||
1244 isOperandEqual (IC_RIGHT (cdp->diCode), op))
1246 /* save it in our list of items */
1247 addSet (&compItems, IC_RESULT (cdp->diCode));
1249 /* also check for those computed from our computed
1250 list . This will take care of situations like
1251 iTemp1 = iTemp0 + 8;
1252 iTemp2 = iTemp1 + 8; */
1253 if (isinSetWith (compItems, (void*)IC_LEFT (cdp->diCode),
1254 (insetwithFunc)isOperandEqual) ||
1255 isinSetWith (compItems, (void*)IC_RIGHT (cdp->diCode),
1256 (insetwithFunc)isOperandEqual))
1258 addSet (&compItems, IC_RESULT (cdp->diCode));
1263 /* now delete all pointer gets with this op */
1264 deleteItemIf (cseSet, ifPointerGet, op);
1265 deleteItemIf (pss, ifPointerSet, op);
1267 /* set the bit vector used by dataFlow computation later */
1268 ebb->ptrsSet = bitVectSetBit (ebb->ptrsSet, op->key);
1269 /* now for the computed items */
1270 for (cop = setFirstItem (compItems); cop; cop = setNextItem (compItems))
1272 ebb->ptrsSet = bitVectSetBit (ebb->ptrsSet, cop->key);
1273 deleteItemIf (cseSet, ifPointerGet, cop);
1274 deleteItemIf (pss, ifPointerSet, cop);
1278 /*-----------------------------------------------------------------*/
1279 /* delGetPointerSucc - delete get pointer from inExprs of succ with */
1280 /* dfnum > supplied */
1281 /*-----------------------------------------------------------------*/
1282 DEFSETFUNC (delGetPointerSucc)
1284 eBBlock *ebp = item;
1285 V_ARG (operand *, op);
1292 if (ebp->dfnum > dfnum)
1294 deleteItemIf (&ebp->inExprs, ifPointerGet, op);
1297 return applyToSet (ebp->succList, delGetPointerSucc, op, dfnum);
1300 /*-----------------------------------------------------------------*/
1301 /* fixUpTypes - KLUGE HACK fixup a lowering problem */
1302 /*-----------------------------------------------------------------*/
1304 fixUpTypes (iCode * ic)
1306 sym_link *t1 = operandType (IC_LEFT (ic)), *t2;
1308 /* if (TARGET_IS_DS390) */
1309 if (options.model == MODEL_FLAT24)
1315 /* for pointer_gets if the types of result & left r the
1316 same then change it type of result to next */
1318 compareType (t2 = operandType (IC_RESULT (ic)), t1) == 1)
1320 setOperandType (IC_RESULT (ic), t2->next);
1324 /*-----------------------------------------------------------------*/
1325 /* isSignedOp - will return 1 if sign is important to operation */
1326 /*-----------------------------------------------------------------*/
1327 static int isSignedOp (iCode *ic)
1348 case GET_VALUE_AT_ADDRESS:
1374 /*-----------------------------------------------------------------*/
1375 /* cseBBlock - common subexpression elimination for basic blocks */
1376 /* this is the hackiest kludgiest routine in the whole */
1377 /* system. also the most important, since almost all */
1378 /* data flow related information is computed by it */
1379 /*-----------------------------------------------------------------*/
1381 cseBBlock (eBBlock * ebb, int computeOnly,
1382 eBBlock ** ebbs, int count)
1388 set *ptrSetSet = NULL;
1390 /* if this block is not reachable */
1394 /* set of common subexpressions */
1395 cseSet = setFromSet (ebb->inExprs);
1397 /* these will be computed by this routine */
1398 setToNull ((void **) &ebb->outDefs);
1399 setToNull ((void **) &ebb->defSet);
1400 setToNull ((void **) &ebb->usesDefs);
1401 setToNull ((void **) &ebb->ptrsSet);
1402 setToNull ((void **) &ebb->addrOf);
1403 setToNull ((void **) &ebb->ldefs);
1405 ebb->outDefs = bitVectCopy (ebb->inDefs);
1406 bitVectDefault = iCodeKey;
1407 ebb->defSet = newBitVect (iCodeKey);
1408 ebb->usesDefs = newBitVect (iCodeKey);
1410 /* for all the instructions in this block do */
1411 for (ic = ebb->sch; ic; ic = ic->next)
1418 ic->eBBlockNum = ebb->bbnum;
1423 /* if this is an assignment from true symbol
1424 to a temp then do pointer post inc/dec optimzation */
1425 if (ic->op == '=' && !POINTER_SET (ic) &&
1426 IS_PTR (operandType (IC_RESULT (ic))))
1428 ptrPostIncDecOpt (ic);
1431 /* clear the def & use chains for the operands involved */
1432 /* in this operation . since it can change due to opts */
1433 unsetDefsAndUses (ic);
1435 if (ic->op == PCALL || ic->op == CALL || ic->op == RECEIVE)
1437 /* add to defSet of the symbol */
1438 OP_DEFS(IC_RESULT (ic))=
1439 bitVectSetBit (OP_DEFS (IC_RESULT (ic)), ic->key);
1440 /* add to the definition set of this block */
1441 ebb->defSet = bitVectSetBit (ebb->defSet, ic->key);
1442 ebb->ldefs = bitVectSetBit (ebb->ldefs, ic->key);
1443 ebb->outDefs = bitVectCplAnd (ebb->outDefs, OP_DEFS (IC_RESULT (ic)));
1444 setUsesDefs (IC_RESULT (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
1445 /* delete global variables from the cseSet
1446 since they can be modified by the function call */
1447 deleteItemIf (&cseSet, ifDefGlobal);
1449 /* and also itemps assigned from globals */
1450 deleteItemIf (&cseSet, ifAssignedFromGlobal);
1452 /* delete all getpointer iCodes from cseSet, this should
1453 be done only for global arrays & pointers but at this
1454 point we don't know if globals, so to be safe do all */
1455 deleteItemIf (&cseSet, ifAnyGetPointer);
1458 /* for pcall & ipush we need to add to the useSet */
1459 if ((ic->op == PCALL ||
1463 IS_SYMOP (IC_LEFT (ic)))
1466 /* check if they can be replaced */
1470 applyToSetFTrue (cseSet, findCheaperOp, IC_LEFT (ic), &pdop, 0);
1472 ReplaceOpWithCheaperOp(&IC_LEFT(ic), pdop);
1474 /* the lookup could have changed it */
1475 if (IS_SYMOP (IC_LEFT (ic)))
1477 OP_USES(IC_LEFT (ic))=
1478 bitVectSetBit (OP_USES (IC_LEFT (ic)), ic->key);
1479 setUsesDefs (IC_LEFT (ic), ebb->defSet,
1480 ebb->outDefs, &ebb->usesDefs);
1484 /* if we a sending a pointer as a parameter
1485 then kill all cse since the pointed to item
1486 might be changed in the function being called */
1487 if ((ic->op == IPUSH || ic->op == SEND) &&
1488 IS_PTR (operandType (IC_LEFT (ic))))
1490 deleteGetPointers (&cseSet, &ptrSetSet, IC_LEFT (ic), ebb);
1491 ebb->ptrsSet = bitVectSetBit (ebb->ptrsSet, IC_LEFT (ic)->key);
1492 for (i = 0; i < count; ebbs[i++]->visited = 0);
1493 applyToSet (ebb->succList, delGetPointerSucc,
1494 IC_LEFT (ic), ebb->dfnum);
1499 /* if jumptable then mark the usage */
1500 if (ic->op == JUMPTABLE)
1502 OP_USES(IC_JTCOND (ic))=
1503 bitVectSetBit (OP_USES (IC_JTCOND (ic)), ic->key);
1504 setUsesDefs (IC_JTCOND (ic), ebb->defSet,
1505 ebb->outDefs, &ebb->usesDefs);
1512 /* do some algebraic optimizations if possible */
1514 while (constFold (ic, cseSet));
1517 if (POINTER_GET (ic) && !IS_PTR (operandType (IC_LEFT (ic))))
1519 setOperandType (IC_LEFT (ic),
1520 aggrToPtr (operandType (IC_LEFT (ic)), FALSE));
1524 if (POINTER_SET (ic) && !IS_PTR (operandType (IC_RESULT (ic))))
1526 setOperandType (IC_RESULT (ic),
1527 aggrToPtr (operandType (IC_RESULT (ic)), FALSE));
1530 /* if this is a condition statment then */
1531 /* check if the condition can be replaced */
1534 ifxOptimize (ic, cseSet, computeOnly,
1540 /* if the assignment & result is a temp */
1541 /* see if we can replace it */
1545 /* update the spill location for this */
1546 updateSpillLocation (ic,0);
1548 if (POINTER_SET (ic) &&
1549 !(IS_BITFIELD (OP_SYMBOL (IC_RESULT (ic))->etype)))
1552 applyToSetFTrue (cseSet, findCheaperOp, IC_RESULT (ic), &pdop, 0);
1553 if (pdop && IS_ITEMP (pdop) && !computeOnly)
1554 ReplaceOpWithCheaperOp (&IC_RESULT(ic), pdop);
1558 checkSign = isSignedOp(ic);
1560 /* do the operand lookup i.e. for both the */
1561 /* right & left operand : check the cseSet */
1562 /* to see if they have been replaced if yes */
1563 /* then replace them with those from cseSet */
1565 /* and left is a symbol */
1566 if (IS_SYMOP (IC_LEFT (ic)) &&
1567 !computeOnly && ic->op != ADDRESS_OF)
1571 applyToSetFTrue (cseSet, findCheaperOp, IC_LEFT (ic), &pdop, checkSign);
1574 if (POINTER_GET (ic))
1576 if (IS_ITEMP (pdop) || IS_OP_LITERAL (pdop))
1578 /* some non dominating block does POINTER_SET with
1579 this variable .. unsafe to remove any POINTER_GETs */
1580 if (bitVectBitValue(ebb->ndompset,IC_LEFT(ic)->key))
1581 ebb->ptrsSet = bitVectSetBit(ebb->ptrsSet,pdop->key);
1582 ReplaceOpWithCheaperOp(&IC_LEFT(ic), pdop);
1585 /* check if there is a pointer set
1586 for the same pointer visible if yes
1587 then change this into an assignment */
1589 if (applyToSetFTrue (cseSet, findPointerSet, IC_LEFT (ic), &pdop, IC_RESULT (ic)) &&
1590 !bitVectBitValue (ebb->ptrsSet, pdop->key))
1593 IC_LEFT (ic) = NULL;
1594 ReplaceOpWithCheaperOp(&IC_RIGHT(ic), pdop);
1595 SET_ISADDR (IC_RESULT (ic), 0);
1601 ReplaceOpWithCheaperOp(&IC_LEFT(ic), pdop);
1608 if (IS_SYMOP (IC_RIGHT (ic)) && !computeOnly)
1612 applyToSetFTrue (cseSet, findCheaperOp, IC_RIGHT (ic), &pdop, checkSign);
1614 ReplaceOpWithCheaperOp(&IC_RIGHT(ic), pdop);
1619 /* if left or right changed then do algebraic */
1623 while (constFold (ic, cseSet));
1626 /* if after all this it becomes a assignment to self
1627 then delete it and continue */
1628 if (ASSIGNMENT_TO_SELF (ic))
1630 remiCodeFromeBBlock (ebb, ic);
1634 /* now we will check to see if the entire */
1635 /* operation has been performed before */
1636 /* and is available */
1637 /* don't do assignments they will be killed */
1638 /* by dead code elimination if required do */
1639 /* it only if result is a temporary */
1641 if (!(POINTER_GET (ic) &&
1642 (IS_BITFIELD (OP_SYMBOL (IC_RESULT (ic))->etype) ||
1643 isOperandVolatile (IC_LEFT (ic), TRUE) ||
1644 bitVectBitValue (ebb->ndompset, IC_LEFT (ic)->key))) &&
1646 IS_ITEMP (IC_RESULT (ic)) &&
1649 applyToSet (cseSet, findPrevIc, ic, &pdic);
1650 if (pdic && compareType (operandType (IC_RESULT (pdic)),
1651 operandType (IC_RESULT (ic))) != 1)
1653 if (pdic && port->cseOk && (*port->cseOk)(ic,pdic) == 0)
1657 /* Alternate code */
1658 if (pdic && IS_ITEMP(IC_RESULT(ic))) {
1659 if (POINTER_GET(ic) && bitVectBitValue(ebb->ptrsSet,IC_LEFT(ic)->key)) {
1660 /* Mmm, found an equivalent pointer get at a lower level.
1661 This could be a loop however with the same pointer set
1664 /* if previous definition found change this to an assignment */
1667 IC_RIGHT(ic) = operandFromOperand(IC_RESULT(pdic));
1668 SET_ISADDR(IC_RESULT(ic),0);
1669 SET_ISADDR(IC_RIGHT (ic),0);
1673 if (!(POINTER_SET (ic)) && IC_RESULT (ic)) {
1674 deleteItemIf (&cseSet, ifDefSymIsX, IC_RESULT (ic));
1675 addSetHead (&cseSet, newCseDef (IC_RESULT (ic), ic));
1679 /* if assignment to a parameter which is not
1680 mine and type is a pointer then delete
1681 pointerGets to take care of aliasing */
1682 if (ASSIGNMENT (ic) &&
1683 OTHERS_PARM (OP_SYMBOL (IC_RESULT (ic))) &&
1684 IS_PTR (operandType (IC_RESULT (ic))))
1686 deleteGetPointers (&cseSet, &ptrSetSet, IC_RIGHT (ic), ebb);
1687 for (i = 0; i < count; ebbs[i++]->visited = 0);
1688 applyToSet (ebb->succList, delGetPointerSucc, IC_RIGHT (ic), ebb->dfnum);
1689 ebb->ptrsSet = bitVectSetBit (ebb->ptrsSet, IC_RIGHT (ic)->key);
1692 /* if this is a pointerget then see if we can replace
1693 this with a previously assigned pointer value */
1694 if (POINTER_GET (ic) &&
1695 !(IS_BITFIELD (OP_SYMBOL (IC_RESULT (ic))->etype) ||
1696 isOperandVolatile (IC_LEFT (ic), TRUE)))
1699 applyToSet (ptrSetSet, findPointerSet, IC_LEFT (ic), &pdop, IC_RESULT (ic));
1700 /* if we find it then locally replace all
1701 references to the result with what we assigned */
1704 replaceAllSymBySym (ic->next, IC_RESULT (ic), pdop, &ebb->ndompset);
1708 /* delete from the cseSet anything that has */
1709 /* operands matching the result of this */
1710 /* except in case of pointer access */
1711 if (!(POINTER_SET (ic)) && IC_RESULT (ic))
1713 deleteItemIf (&cseSet, ifOperandsHave, IC_RESULT (ic));
1714 /* delete any previous definitions */
1715 ebb->defSet = bitVectCplAnd (ebb->defSet, OP_DEFS (IC_RESULT (ic)));
1719 /* add the left & right to the defUse set */
1720 if (IC_LEFT (ic) && IS_SYMOP (IC_LEFT (ic)))
1722 OP_USES(IC_LEFT (ic))=
1723 bitVectSetBit (OP_USES (IC_LEFT (ic)), ic->key);
1724 setUsesDefs (IC_LEFT (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
1728 if (IC_RIGHT (ic) && IS_SYMOP (IC_RIGHT (ic)))
1730 OP_USES(IC_RIGHT (ic))=
1731 bitVectSetBit (OP_USES (IC_RIGHT (ic)), ic->key);
1732 setUsesDefs (IC_RIGHT (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
1736 /* for the result it is special case, put the result */
1737 /* in the defuseSet if it a pointer or array access */
1738 if (POINTER_SET (defic))
1740 OP_USES(IC_RESULT (ic))=
1741 bitVectSetBit (OP_USES (IC_RESULT (ic)), ic->key);
1742 setUsesDefs (IC_RESULT (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
1743 deleteItemIf (&cseSet, ifPointerGet, IC_RESULT (ic));
1744 ebb->ptrsSet = bitVectSetBit (ebb->ptrsSet, IC_RESULT (ic)->key);
1745 /* delete from inexpressions of all successors which
1746 have dfNum > than this block */
1747 for (i = 0; i < count; ebbs[i++]->visited = 0);
1748 applyToSet (ebb->succList, delGetPointerSucc, IC_RESULT (ic), ebb->dfnum);
1750 /* delete from cseSet all other pointer sets
1752 deleteItemIf (&ptrSetSet, ifPointerSet, IC_RESULT (ic));
1753 /* add to the local pointerset set */
1754 addSetHead (&ptrSetSet, newCseDef (IC_RESULT (ic), ic));
1757 /* add the result to defintion set */ if (IC_RESULT (ic))
1759 OP_DEFS(IC_RESULT (ic))=
1760 bitVectSetBit (OP_DEFS (IC_RESULT (ic)), ic->key);
1761 ebb->defSet = bitVectSetBit (ebb->defSet, ic->key);
1762 ebb->outDefs = bitVectCplAnd (ebb->outDefs, OP_DEFS (IC_RESULT (ic)));
1763 ebb->ldefs = bitVectSetBit (ebb->ldefs, ic->key);
1767 /* if this is an addressof instruction then */
1768 /* put the symbol in the address of list & */
1769 /* delete it from the cseSet */
1770 if (defic->op == ADDRESS_OF)
1772 addSetHead (&ebb->addrOf, IC_LEFT (ic));
1773 deleteItemIf (&cseSet, ifDefSymIsX, IC_LEFT (ic));
1777 setToNull ((void **) &ebb->outExprs);
1778 ebb->outExprs = cseSet;
1779 ebb->outDefs = bitVectUnion (ebb->outDefs, ebb->defSet);
1780 ebb->ptrsSet = bitVectUnion (ebb->ptrsSet, ebb->inPtrsSet);
1784 /*-----------------------------------------------------------------*/
1785 /* cseAllBlocks - will sequentially go thru & do cse for all blocks */
1786 /*-----------------------------------------------------------------*/
1788 cseAllBlocks (eBBlock ** ebbs, int count)
1793 /* if optimization turned off */
1795 for (i = 0; i < count; i++)
1796 change += cseBBlock (ebbs[i], FALSE, ebbs, count);