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 -------------------------------------------------------------------------*/
27 #include "dbuf_string.h"
30 /*-----------------------------------------------------------------*/
31 /* newCseDef - new cseDef */
32 /*-----------------------------------------------------------------*/
34 newCseDef (operand * sym, iCode * ic)
39 cdp = Safe_alloc (sizeof (cseDef));
44 cdp->ancestors = newBitVect(iCodeKey);
46 cdp->fromAddrTaken = 0;
48 if (ic->op!=IF && ic->op!=JUMPTABLE)
50 if (IC_LEFT (ic) && IS_SYMOP (IC_LEFT (ic)))
52 bitVectSetBit (cdp->ancestors, IC_LEFT (ic)->key);
53 cdp->fromGlobal |= isOperandGlobal (IC_LEFT (ic));
54 cdp->fromAddrTaken |= OP_SYMBOL (IC_LEFT (ic))->addrtaken;
56 if (IC_RIGHT (ic) && IS_SYMOP (IC_RIGHT (ic)))
58 bitVectSetBit (cdp->ancestors, IC_RIGHT (ic)->key);
59 cdp->fromGlobal |= isOperandGlobal (IC_RIGHT (ic));
60 cdp->fromAddrTaken |= OP_SYMBOL (IC_RIGHT (ic))->addrtaken;
68 updateCseDefAncestors(cseDef *cdp, set * cseSet)
72 iCode *ic = cdp->diCode;
74 if (ic->op!=IF && ic->op!=JUMPTABLE)
76 if (IC_LEFT (ic) && IS_SYMOP (IC_LEFT (ic)))
78 bitVectSetBit (cdp->ancestors, IC_LEFT (ic)->key);
79 for (sl = cseSet; sl; sl = sl->next)
82 if (loop->sym->key == IC_LEFT (ic)->key)
84 cdp->ancestors = bitVectUnion (cdp->ancestors, loop->ancestors);
85 cdp->fromGlobal |= loop->fromGlobal;
86 cdp->fromAddrTaken |= loop->fromAddrTaken;
91 if (IC_RIGHT (ic) && IS_SYMOP (IC_RIGHT (ic)))
93 bitVectSetBit (cdp->ancestors, IC_RIGHT (ic)->key);
94 for (sl = cseSet; sl; sl = sl->next)
97 if (loop->sym->key == IC_RIGHT (ic)->key)
99 cdp->ancestors = bitVectUnion (cdp->ancestors, loop->ancestors);
100 cdp->fromGlobal |= loop->fromGlobal;
101 cdp->fromAddrTaken |= loop->fromAddrTaken;
110 /*-----------------------------------------------------------------*/
111 /* int isCseDefEqual - two definitions are equal */
112 /*-----------------------------------------------------------------*/
114 isCseDefEqual (void *vsrc, void *vdest)
117 cseDef *dest = vdest;
122 return (src->key == dest->key &&
123 src->diCode == dest->diCode);
127 /*-----------------------------------------------------------------*/
128 /* pcseDef - in the cseDef */
129 /*-----------------------------------------------------------------*/
131 pcseDef (void *item, va_list ap)
140 fprintf (stdout, "**null op**");
141 printOperand (cdp->sym, stdout);
142 icTab = getTableEntry (cdp->diCode->op);
143 dbuf_init (&dbuf, 1024);
144 icTab->iCodePrint (&dbuf, cdp->diCode, icTab->printName);
145 dbuf_write_and_destroy (&dbuf, stdout);
149 void ReplaceOpWithCheaperOp(operand **op, operand *cop) {
151 printf ("ReplaceOpWithCheaperOp\n\t");
152 printOperand (*op, stdout);
154 printOperand (cop, stdout);
156 // if op is a register equivalent
157 if (IS_ITEMP(cop) && IS_SYMOP((*op)) && OP_SYMBOL((*op))->isreqv) {
158 operand **rop = &OP_SYMBOL((*op))->usl.spillLoc->reqv;
159 if (isOperandEqual(*rop, *op)) {
162 OP_SYMBOL((*op))->isreqv=0;
163 OP_SYMBOL(cop)->isreqv=1;
173 /*-----------------------------------------------------------------*/
174 /* replaceAllSymBySym - replaces all operands by operand in an */
175 /* instruction chain */
176 /*-----------------------------------------------------------------*/
178 replaceAllSymBySym (iCode * ic, operand * from, operand * to, bitVect ** ndpset)
183 printf ("replaceAllSymBySym\n\t");
184 printOperand (from, stdout);
186 printOperand (to, stdout);
189 for (lic = ic; lic; lic = lic->next)
193 /* do the special cases first */
197 IC_COND (lic)->key == from->key)
200 bitVectUnSetBit (OP_USES (from), lic->key);
201 OP_USES(to)=bitVectSetBit (OP_USES (to), lic->key);
202 isaddr = IC_COND (lic)->isaddr;
203 IC_COND (lic) = operandFromOperand (to);
204 IC_COND (lic)->isaddr = isaddr;
210 if (lic->op == JUMPTABLE)
213 IC_JTCOND (lic)->key == from->key)
216 bitVectUnSetBit (OP_USES (from), lic->key);
217 OP_USES(to)=bitVectSetBit (OP_USES (to), lic->key);
218 isaddr = IC_COND (lic)->isaddr;
219 IC_JTCOND (lic) = operandFromOperand (to);
220 IC_JTCOND (lic)->isaddr = isaddr;
227 IC_RESULT (lic) && IC_RESULT (lic)->key == from->key)
229 /* maintain du chains */
230 if (POINTER_SET (lic))
232 bitVectUnSetBit (OP_USES (from), lic->key);
233 OP_USES(to)=bitVectSetBit (OP_USES (to), lic->key);
235 /* also check if the "from" was in the non-dominating
236 pointer sets and replace it with "to" in the bitVector */
237 if (bitVectBitValue (*ndpset, from->key))
239 bitVectUnSetBit (*ndpset, from->key);
240 bitVectSetBit (*ndpset, to->key);
246 bitVectUnSetBit (OP_DEFS (from), lic->key);
247 OP_DEFS(to)=bitVectSetBit (OP_DEFS (to), lic->key);
249 isaddr = IC_RESULT (lic)->isaddr;
250 IC_RESULT (lic) = operandFromOperand (to);
251 IC_RESULT (lic)->isaddr = isaddr;
255 IC_RIGHT (lic) && IC_RIGHT (lic)->key == from->key)
257 bitVectUnSetBit (OP_USES (from), lic->key);
258 OP_USES(to)=bitVectSetBit (OP_USES (to), lic->key);
259 isaddr = IC_RIGHT (lic)->isaddr;
260 IC_RIGHT (lic) = operandFromOperand (to);
261 IC_RIGHT (lic)->isaddr = isaddr;
265 IC_LEFT (lic) && IC_LEFT (lic)->key == from->key)
267 bitVectUnSetBit (OP_USES (from), lic->key);
268 OP_USES(to)=bitVectSetBit (OP_USES (to), lic->key);
269 isaddr = IC_LEFT (lic)->isaddr;
270 IC_LEFT (lic) = operandFromOperand (to);
271 IC_LEFT (lic)->isaddr = isaddr;
276 /*-----------------------------------------------------------------*/
277 /* iCodeKeyIs - if the icode keys match then return 1 */
278 /*-----------------------------------------------------------------*/
279 DEFSETFUNC (iCodeKeyIs)
284 if (cdp->diCode->key == key)
290 /*-----------------------------------------------------------------*/
291 /* removeFromInExprs - removes an icode from inexpressions */
292 /*-----------------------------------------------------------------*/
293 DEFSETFUNC (removeFromInExprs)
297 V_ARG (operand *, from);
298 V_ARG (operand *, to);
299 V_ARG (eBBlock *, cbp);
305 deleteItemIf (&ebp->inExprs, iCodeKeyIs, ic->key);
306 if (ebp != cbp && !bitVectBitValue (cbp->domVect, ebp->bbnum))
307 replaceAllSymBySym (ebp->sch, from, to, &ebp->ndompset);
309 applyToSet (ebp->succList, removeFromInExprs, ic, from, to, cbp);
313 /*-----------------------------------------------------------------*/
314 /* isGlobalInNearSpace - return TRUE if valriable is a globalin data */
315 /*-----------------------------------------------------------------*/
317 isGlobalInNearSpace (operand * op)
319 sym_link *type = getSpec (operandType (op));
320 /* this is 8051 specific: optimization
321 suggested by Jean-Louis VERN, with 8051s we have no
322 advantage of putting variables in near space into
324 if (isOperandGlobal (op) && !IN_FARSPACE (SPEC_OCLS (type)) &&
325 IN_DIRSPACE (SPEC_OCLS (type)))
331 /*-----------------------------------------------------------------*/
332 /* findCheaperOp - cseBBlock support routine, will check to see if */
333 /* we have a operand previously defined */
334 /*-----------------------------------------------------------------*/
335 DEFSETFUNC (findCheaperOp)
338 V_ARG (operand *, cop);
339 V_ARG (operand **, opp);
340 V_ARG (int, checkSign);
342 /* if we have already found it */
346 /* not found it yet check if this is the one */
347 /* and this is not the defining one */
348 if (cop->key == cdp->key)
351 /* do a special check this will help in */
352 /* constant propagation & dead code elim */
353 /* for assignments only */
354 if (cdp->diCode->op == '=') {
355 /* if the result is volatile then return result */
356 if (IS_OP_VOLATILE (IC_RESULT (cdp->diCode)))
357 *opp = IC_RESULT (cdp->diCode);
359 /* if this is a straight assignment and
360 left is a temp then prefer the temporary to the
362 if (!POINTER_SET (cdp->diCode) &&
363 IS_ITEMP (IC_RESULT (cdp->diCode)) &&
364 IS_TRUE_SYMOP (IC_RIGHT (cdp->diCode)))
365 *opp = IC_RESULT (cdp->diCode);
367 /* if straight assignement && and both
368 are temps then prefer the one that
369 will not need extra space to spil, also
370 take into consideration if right side
371 an induction variable
373 if (!POINTER_SET (cdp->diCode) &&
374 IS_ITEMP (IC_RESULT (cdp->diCode)) &&
375 IS_ITEMP (IC_RIGHT (cdp->diCode)) &&
376 !OP_SYMBOL (IC_RIGHT (cdp->diCode))->isind &&
377 !OP_SYMBOL(IC_RIGHT (cdp->diCode))->isreqv &&
378 ((!SPIL_LOC (IC_RIGHT (cdp->diCode)) &&
379 SPIL_LOC (IC_RESULT (cdp->diCode))) ||
380 (SPIL_LOC (IC_RESULT (cdp->diCode)) &&
381 SPIL_LOC (IC_RESULT (cdp->diCode)) ==
382 SPIL_LOC (IC_RIGHT (cdp->diCode)))))
383 *opp = IC_RESULT (cdp->diCode);
385 *opp = IC_RIGHT (cdp->diCode);
389 *opp = IC_RESULT (cdp->diCode);
392 /* if this is an assign to a temp. then check
393 if the right side is this then return this */
394 if (IS_TRUE_SYMOP (cop) &&
395 cdp->diCode->op == '=' &&
396 !POINTER_SET (cdp->diCode) &&
397 cop->key == IC_RIGHT (cdp->diCode)->key &&
398 !isGlobalInNearSpace (IC_RIGHT (cdp->diCode)) &&
399 IS_ITEMP (IC_RESULT (cdp->diCode)))
400 *opp = IC_RESULT (cdp->diCode);
403 (isOperandLiteral(*opp) || !checkSign ||
405 IS_SPEC(operandType (cop)) && IS_SPEC(operandType (*opp)) &&
406 (SPEC_USIGN(operandType (cop))==SPEC_USIGN(operandType (*opp)) &&
407 (SPEC_LONG(operandType (cop))==SPEC_LONG(operandType (*opp)))))))
410 if ((isGlobalInNearSpace (cop) &&
411 !isOperandLiteral (*opp)) ||
412 isOperandVolatile (*opp, FALSE)
419 if (cop->key == (*opp)->key)
425 if ((*opp)->isaddr != cop->isaddr && IS_ITEMP (cop))
427 *opp = operandFromOperand (*opp);
428 (*opp)->isaddr = cop->isaddr;
431 /* copy signedness to literal operands */
432 if (IS_SPEC(operandType (cop)) && IS_SPEC(operandType (*opp))
433 && isOperandLiteral(*opp)
434 && SPEC_NOUN(operandType(*opp)) == SPEC_NOUN(operandType(cop))
435 && SPEC_USIGN(operandType(*opp)) != SPEC_USIGN(operandType(cop)))
437 SPEC_USIGN(operandType(*opp)) = SPEC_USIGN(operandType(cop));
440 if (IS_SPEC(operandType (cop)) && IS_SPEC(operandType (*opp)) &&
441 SPEC_NOUN(operandType(cop)) != SPEC_NOUN(operandType(*opp)))
443 // special case: we can make an unsigned char literal
444 // into an int literal with no cost.
445 if (isOperandLiteral(*opp)
446 && SPEC_NOUN(operandType(*opp)) == V_CHAR
447 && SPEC_NOUN(operandType(cop)) == V_INT)
449 *opp = operandFromOperand (*opp);
450 SPEC_NOUN(operandType(*opp)) = V_INT;
468 /*-----------------------------------------------------------------*/
469 /* findPointerSet - finds the right side of a pointer set op */
470 /*-----------------------------------------------------------------*/
471 DEFSETFUNC (findPointerSet)
474 V_ARG (operand *, op);
475 V_ARG (operand **, opp);
476 V_ARG (operand *, rop);
478 if (POINTER_SET (cdp->diCode) &&
479 IC_RESULT (cdp->diCode)->key == op->key &&
480 !isOperandVolatile (IC_RESULT (cdp->diCode), TRUE) &&
481 !isOperandVolatile (IC_RIGHT (cdp->diCode), TRUE) &&
482 getSize (operandType (IC_RIGHT (cdp->diCode))) ==
483 getSize (operandType (rop)))
485 if (IS_SPEC (operandType (IC_RIGHT (cdp->diCode))) &&
486 SPEC_USIGN (operandType (IC_RIGHT (cdp->diCode))) !=
487 SPEC_USIGN (operandType (rop)))
490 Reminder for Bernhard: check of signedness
491 could be unnecessary together with 'checkSign', if
492 signedness of operation is stored in ic */
495 *opp = IC_RIGHT (cdp->diCode);
502 /*-----------------------------------------------------------------*/
503 /* findPrevIc - cseBBlock support function will return the iCode */
504 /* which matches the current one */
505 /*-----------------------------------------------------------------*/
506 DEFSETFUNC (findPrevIc)
510 V_ARG (iCode **, icp);
512 /* if already found */
516 /* if the iCodes are the same */
517 if (isiCodeEqual (ic, cdp->diCode) &&
518 isOperandEqual (cdp->sym, IC_RESULT (cdp->diCode)))
524 /* if iCodes are not the same */
525 /* see the operands maybe interchanged */
526 if (ic->op == cdp->diCode->op &&
527 IS_ASSOCIATIVE(ic) &&
528 isOperandEqual (IC_LEFT (ic), IC_RIGHT (cdp->diCode)) &&
529 isOperandEqual (IC_RIGHT (ic), IC_LEFT (cdp->diCode)))
538 /*-------------------------------------------------------------------*/
539 /* ifAssignedFromGlobal - if definition is an assignment from global */
540 /*-------------------------------------------------------------------*/
541 DEFSETFUNC (ifAssignedFromGlobal)
544 iCode *dic=cdp->diCode;
546 if (dic->op=='=' && isOperandGlobal(IC_RIGHT(dic))) {
552 /*-------------------------------------------------------------------*/
553 /* ifFromGlobal - if definition is derived from global */
554 /*-------------------------------------------------------------------*/
555 DEFSETFUNC (ifFromGlobal)
559 return cdp->fromGlobal;
562 /*-----------------------------------------------------------------*/
563 /* ifDefGlobal - if definition is global */
564 /*-----------------------------------------------------------------*/
565 DEFSETFUNC (ifDefGlobal)
569 return (isOperandGlobal (cdp->sym));
572 /*-------------------------------------------------------------------*/
573 /* ifFromAddrTaken - if definition is derived from a symbol whose */
574 /* address was taken */
575 /*-------------------------------------------------------------------*/
576 DEFSETFUNC (ifFromAddrTaken)
580 return cdp->fromAddrTaken;
584 /*-----------------------------------------------------------------*/
585 /* ifAnyGetPointer - if get pointer icode */
586 /*-----------------------------------------------------------------*/
587 DEFSETFUNC (ifAnyGetPointer)
591 if (cdp->diCode && POINTER_GET (cdp->diCode))
596 /*-----------------------------------------------------------------*/
597 /* ifOperandsHave - if any of the operand are the same as this */
598 /*-----------------------------------------------------------------*/
599 DEFSETFUNC (ifOperandsHave)
602 V_ARG (operand *, op);
604 if (bitVectBitValue(cdp->ancestors, op->key))
607 if (IC_LEFT (cdp->diCode) &&
608 IS_SYMOP (IC_LEFT (cdp->diCode)) &&
609 IC_LEFT (cdp->diCode)->key == op->key)
612 if (IC_RIGHT (cdp->diCode) &&
613 IS_SYMOP (IC_RIGHT (cdp->diCode)) &&
614 IC_RIGHT (cdp->diCode)->key == op->key)
617 /* or if any of the operands are volatile */
618 if (IC_LEFT (cdp->diCode) &&
619 IS_OP_VOLATILE (IC_LEFT (cdp->diCode)))
622 if (IC_RIGHT (cdp->diCode) &&
623 IS_OP_VOLATILE (IC_RIGHT (cdp->diCode)))
627 if (IC_RESULT (cdp->diCode) &&
628 IS_OP_VOLATILE (IC_RESULT (cdp->diCode)))
634 /*-----------------------------------------------------------------*/
635 /* ifDefSymIs - if a definition is found in the set */
636 /*-----------------------------------------------------------------*/
638 ifDefSymIs (set * cseSet, operand * sym)
643 if (!sym || !IS_SYMOP (sym))
645 for (sl = cseSet; sl; sl = sl->next)
648 if (loop->sym->key == sym->key)
655 /*-----------------------------------------------------------------*/
656 /* ifDefSymIsX - will return 1 if the symbols match */
657 /*-----------------------------------------------------------------*/
658 DEFSETFUNC (ifDefSymIsX)
661 V_ARG (operand *, op);
665 match = cdp->sym->key == op->key;
667 match = (isOperandEqual (cdp->sym, op));
670 printf("%s ",OP_SYMBOL(cdp->sym)->name);
676 /*-----------------------------------------------------------------*/
677 /* ifDiCodeIs - returns true if diCode is same */
678 /*-----------------------------------------------------------------*/
680 ifDiCodeIs (set * cseSet, iCode * ic)
688 for (sl = cseSet; sl; sl = sl->next)
691 if (loop->diCode == ic)
698 /*-----------------------------------------------------------------*/
699 /* ifPointerGet - returns true if the icode is pointer get sym */
700 /*-----------------------------------------------------------------*/
701 DEFSETFUNC (ifPointerGet)
704 V_ARG (operand *, op);
705 iCode *dic = cdp->diCode;
706 operand *left = IC_LEFT (cdp->diCode);
708 if (POINTER_GET (dic) && left->key == op->key)
714 /*-----------------------------------------------------------------*/
715 /* ifPointerSet - returns true if the icode is pointer set sym */
716 /*-----------------------------------------------------------------*/
717 DEFSETFUNC (ifPointerSet)
720 V_ARG (operand *, op);
722 if (POINTER_SET (cdp->diCode) &&
723 IC_RESULT (cdp->diCode)->key == op->key)
729 /*-----------------------------------------------------------------*/
730 /* ifDiCodeIsX - will return 1 if the symbols match */
731 /*-----------------------------------------------------------------*/
732 DEFSETFUNC (ifDiCodeIsX)
737 return cdp->diCode == ic;
741 /*-----------------------------------------------------------------*/
742 /* findBackwardDef - scan backwards to find deinition of operand */
743 /*-----------------------------------------------------------------*/
744 iCode *findBackwardDef(operand *op,iCode *ic)
748 for (lic = ic; lic ; lic = lic->prev) {
749 if (IC_RESULT(lic) && isOperandEqual(op,IC_RESULT(lic)))
755 /*-----------------------------------------------------------------*/
756 /* algebraicOpts - does some algebraic optimizations */
757 /*-----------------------------------------------------------------*/
759 algebraicOpts (iCode * ic, eBBlock * ebp)
761 /* we don't deal with the following iCodes
772 /* if both operands present & ! IFX */
773 /* then if they are both literal we */
774 /* perform the operation right now */
775 if (IC_RESULT (ic) &&
778 IS_OP_LITERAL (IC_LEFT (ic)) &&
779 IS_OP_LITERAL (IC_RIGHT (ic)))
782 IC_RIGHT (ic) = operandOperation (IC_LEFT (ic),
785 operandType (IC_RESULT (ic)));
788 SET_RESULT_RIGHT (ic);
792 /* if not ifx & only one operand present */
793 if (IC_RESULT (ic) &&
795 IS_OP_LITERAL (IC_LEFT (ic)) &&
799 IC_RIGHT (ic) = operandOperation (IC_LEFT (ic),
802 operandType (IC_RESULT (ic)));
805 SET_RESULT_RIGHT (ic);
810 /* a special case : or in short a kludgy solution will think
811 about a better solution over a glass of wine someday */
812 if (ic->op == GET_VALUE_AT_ADDRESS)
815 if (IS_ITEMP (IC_RESULT (ic)) &&
816 IS_TRUE_SYMOP (IC_LEFT (ic)))
820 IC_RIGHT (ic) = operandFromOperand (IC_LEFT (ic));
821 IC_RIGHT (ic)->isaddr = 0;
823 IC_RESULT (ic) = operandFromOperand (IC_RESULT (ic));
824 IC_RESULT (ic)->isaddr = 0;
825 setOperandType (IC_RESULT (ic), operandType (IC_RIGHT (ic)));
829 if (IS_ITEMP (IC_LEFT (ic)) &&
830 IS_ITEMP (IC_RESULT (ic)) &&
831 /* !OP_SYMBOL(IC_RESULT(ic))->isreqv && */
832 /* !OP_SYMBOL(IC_LEFT(ic))->isreqv && */
833 !IC_LEFT (ic)->isaddr)
836 IC_RIGHT (ic) = operandFromOperand (IC_LEFT (ic));
837 IC_RIGHT (ic)->isaddr = 0;
838 IC_RESULT (ic) = operandFromOperand (IC_RESULT (ic));
839 IC_RESULT (ic)->isaddr = 0;
847 /* depending on the operation */
851 /* if adding the same thing change to left shift by 1 */
852 if (IC_LEFT (ic)->key == IC_RIGHT (ic)->key &&
853 !(IS_FLOAT (operandType (IC_RESULT (ic)))
854 || IS_FIXED(operandType (IC_RESULT (ic)))))
857 IC_RIGHT (ic) = operandFromLit (1);
860 /* if addition then check if one of them is a zero */
861 /* if yes turn it into assignmnt or cast */
862 if (IS_OP_LITERAL (IC_LEFT (ic)) &&
863 operandLitValue (IC_LEFT (ic)) == 0.0)
866 typematch = compareType (operandType (IC_RESULT (ic)),
867 operandType (IC_RIGHT (ic)));
871 IC_LEFT (ic) = operandFromLink (operandType (IC_RESULT (ic)));
879 /* for completely different types, preserve the source type */
880 IC_RIGHT (ic) = operandFromOperand (IC_RIGHT (ic));
881 setOperandType (IC_RIGHT (ic), operandType (IC_RESULT (ic)));
884 SET_ISADDR (IC_RESULT (ic), 0);
885 SET_ISADDR (IC_RIGHT (ic), 0);
888 if (IS_OP_LITERAL (IC_RIGHT (ic)) &&
889 operandLitValue (IC_RIGHT (ic)) == 0.0)
892 typematch = compareType (operandType (IC_RESULT (ic)),
893 operandType (IC_LEFT (ic)));
897 IC_RIGHT (ic) = IC_LEFT (ic);
898 IC_LEFT (ic) = operandFromLink (operandType (IC_RESULT (ic)));
903 IC_RIGHT (ic) = IC_LEFT (ic);
907 /* for completely different types, preserve the source type */
908 IC_RIGHT (ic) = operandFromOperand (IC_RIGHT (ic));
909 setOperandType (IC_RIGHT (ic), operandType (IC_RESULT (ic)));
912 SET_ISADDR (IC_RIGHT (ic), 0);
913 SET_ISADDR (IC_RESULT (ic), 0);
918 /* if subtracting the the same thing then zero */
919 if (IC_LEFT (ic)->key == IC_RIGHT (ic)->key)
922 IC_RIGHT (ic) = operandFromLit (0);
924 IC_RESULT (ic) = operandFromOperand (IC_RESULT (ic));
925 IC_RESULT (ic)->isaddr = 0;
929 /* if subtraction then check if one of the operand */
930 /* is zero then depending on which operand change */
931 /* to assignment or unary minus */
932 if (IS_OP_LITERAL (IC_RIGHT (ic)) &&
933 operandLitValue (IC_RIGHT (ic)) == 0.0)
935 /* right size zero change to assignment */
937 IC_RIGHT (ic) = IC_LEFT (ic);
939 SET_ISADDR (IC_RIGHT (ic), 0);
940 SET_ISADDR (IC_RESULT (ic), 0);
943 if (IS_OP_LITERAL (IC_LEFT (ic)) &&
944 operandLitValue (IC_LEFT (ic)) == 0.0)
946 /* left zero turn into an unary minus */
948 IC_LEFT (ic) = IC_RIGHT (ic);
949 IC_RIGHT (ic) = NULL;
953 /* if multiplication then check if either of */
954 /* them is zero then the result is zero */
955 /* if either of them is one then result is */
958 if (IS_OP_LITERAL (IC_LEFT (ic)))
961 if (operandLitValue (IC_LEFT (ic)) == 0.0)
964 IC_RIGHT (ic) = IC_LEFT (ic);
966 SET_RESULT_RIGHT (ic);
969 if (operandLitValue (IC_LEFT (ic)) == 1.0)
971 /* '*' can have two unsigned chars as operands */
972 /* and an unsigned int as result. */
973 if (compareType (operandType (IC_RESULT (ic)),
974 operandType (IC_RIGHT (ic))) == 1)
978 SET_RESULT_RIGHT (ic);
983 IC_LEFT (ic) = operandFromOperand (IC_LEFT (ic));
984 IC_LEFT (ic)->type = TYPE;
985 IC_LEFT (ic)->isLiteral = 0;
986 setOperandType (IC_LEFT (ic), operandType (IC_RESULT (ic)));
992 if (IS_OP_LITERAL (IC_RIGHT (ic)))
995 if (operandLitValue (IC_RIGHT (ic)) == 0.0)
999 SET_RESULT_RIGHT (ic);
1003 if (operandLitValue (IC_RIGHT (ic)) == 1.0)
1005 /* '*' can have two unsigned chars as operands */
1006 /* and an unsigned int as result. */
1007 if (compareType (operandType (IC_RESULT (ic)),
1008 operandType (IC_LEFT (ic))) == 1)
1011 IC_RIGHT (ic) = IC_LEFT (ic);
1012 IC_LEFT (ic) = NULL;
1013 SET_RESULT_RIGHT (ic);
1021 IC_RIGHT (ic) = IC_LEFT (ic);
1022 IC_LEFT (ic) = operandFromOperand (op);
1023 IC_LEFT (ic)->type = TYPE;
1024 IC_LEFT (ic)->isLiteral = 0;
1025 setOperandType (IC_LEFT (ic), operandType (IC_RESULT (ic)));
1032 /* if division by self then 1 */
1033 if (IC_LEFT (ic)->key == IC_RIGHT (ic)->key)
1036 IC_RIGHT (ic) = operandFromLit (1);
1037 IC_LEFT (ic) = NULL;
1038 IC_RESULT (ic) = operandFromOperand (IC_RESULT (ic));
1039 IC_RESULT (ic)->isaddr = 0;
1042 /* if this is a division then check if right */
1043 /* is one then change it to an assignment */
1044 if (IS_OP_LITERAL (IC_RIGHT (ic)) &&
1045 operandLitValue (IC_RIGHT (ic)) == 1.0)
1049 IC_RIGHT (ic) = IC_LEFT (ic);
1050 IC_LEFT (ic) = NULL;
1051 SET_RESULT_RIGHT (ic);
1055 /* if both are the same for an comparison operators */
1059 if (isOperandEqual (IC_LEFT (ic), IC_RIGHT (ic)))
1062 IC_RIGHT (ic) = operandFromLit (1);
1063 IC_LEFT (ic) = NULL;
1064 SET_RESULT_RIGHT (ic);
1070 if (isOperandEqual (IC_LEFT (ic), IC_RIGHT (ic)))
1073 IC_RIGHT (ic) = operandFromLit (0);
1074 IC_LEFT (ic) = NULL;
1075 SET_RESULT_RIGHT (ic);
1080 sym_link *otype = operandType(IC_RIGHT(ic));
1081 sym_link *ctype = operandType(IC_LEFT(ic));
1082 /* if this is a cast of a literal value */
1083 if (IS_OP_LITERAL (IC_RIGHT (ic)) &&
1084 !(IS_GENPTR(ctype) && (IS_PTR(otype) && !IS_GENPTR(otype)))) {
1087 operandFromValue (valCastLiteral (operandType (IC_LEFT (ic)),
1088 operandLitValue (IC_RIGHT (ic))));
1089 IC_LEFT (ic) = NULL;
1090 SET_ISADDR (IC_RESULT (ic), 0);
1092 /* if casting to the same */
1093 if (compareType (operandType (IC_RESULT (ic)),
1094 operandType (IC_RIGHT (ic))) == 1) {
1096 IC_LEFT (ic) = NULL;
1097 SET_ISADDR (IC_RESULT (ic), 0);
1102 if (IS_OP_LITERAL (IC_LEFT (ic)))
1106 (operandLitValue (IC_LEFT (ic)) == 0 ?
1107 operandFromLit (1) : operandFromLit (0));
1108 IC_LEFT (ic) = NULL;
1109 SET_ISADDR (IC_RESULT (ic), 0);
1113 /* if both operands are equal */
1114 /* if yes turn it into assignment */
1115 if (isOperandEqual (IC_LEFT (ic), IC_RIGHT (ic)))
1117 if (IS_OP_VOLATILE (IC_LEFT (ic)))
1119 iCode *newic = newiCode (DUMMY_READ_VOLATILE, NULL, IC_LEFT (ic));
1120 IC_RESULT (newic) = IC_LEFT (ic);
1121 newic->lineno = ic->lineno;
1122 addiCodeToeBBlock (ebp, newic, ic->next);
1125 IC_LEFT (ic) = NULL;
1126 SET_RESULT_RIGHT (ic);
1129 /* swap literal to right ic */
1130 if (IS_OP_LITERAL (IC_LEFT (ic)))
1135 IC_LEFT (ic) = IC_RIGHT (ic);
1138 if (IS_OP_LITERAL (IC_RIGHT (ic)))
1140 /* if BITWISEAND then check if one of them is a zero */
1141 /* if yes turn it into 0 assignment */
1142 if (operandLitValue (IC_RIGHT (ic)) == 0.0)
1144 if (IS_OP_VOLATILE (IC_LEFT (ic)))
1146 iCode *newic = newiCode (DUMMY_READ_VOLATILE, NULL, IC_LEFT (ic));
1147 IC_RESULT (newic) = IC_LEFT (ic);
1148 newic->lineno = ic->lineno;
1149 addiCodeToeBBlock (ebp, newic, ic->next);
1152 IC_LEFT (ic) = NULL;
1153 SET_RESULT_RIGHT (ic);
1156 /* if BITWISEAND then check if one of them is 0xff... */
1157 /* if yes turn it into assignment */
1161 switch (getSize (operandType (IC_RIGHT (ic))))
1175 if (((unsigned) double2ul (operandLitValue (IC_RIGHT (ic))) & val) == val)
1178 IC_RIGHT (ic) = IC_LEFT (ic);
1179 IC_LEFT (ic) = NULL;
1180 SET_RESULT_RIGHT (ic);
1187 /* if both operands are equal */
1188 /* if yes turn it into assignment */
1189 if (isOperandEqual (IC_LEFT (ic), IC_RIGHT (ic)))
1191 if (IS_OP_VOLATILE (IC_LEFT (ic)))
1193 iCode *newic = newiCode (DUMMY_READ_VOLATILE, NULL, IC_LEFT (ic));
1194 IC_RESULT (newic) = IC_LEFT (ic);
1195 newic->lineno = ic->lineno;
1196 addiCodeToeBBlock (ebp, newic, ic->next);
1199 IC_LEFT (ic) = NULL;
1200 SET_RESULT_RIGHT (ic);
1203 /* swap literal to right ic */
1204 if (IS_OP_LITERAL (IC_LEFT (ic)))
1209 IC_LEFT (ic) = IC_RIGHT (ic);
1212 if (IS_OP_LITERAL (IC_RIGHT (ic)))
1214 /* if BITWISEOR then check if one of them is a zero */
1215 /* if yes turn it into assignment */
1216 if (operandLitValue (IC_RIGHT (ic)) == 0.0)
1219 IC_RIGHT (ic) = IC_LEFT (ic);
1220 IC_LEFT (ic) = NULL;
1221 SET_RESULT_RIGHT (ic);
1224 /* if BITWISEOR then check if one of them is 0xff... */
1225 /* if yes turn it into 0xff... assignment */
1229 switch (getSize (operandType (IC_RIGHT (ic))))
1243 if (((unsigned) double2ul (operandLitValue (IC_RIGHT (ic))) & val) == val)
1245 if (IS_OP_VOLATILE (IC_LEFT (ic)))
1247 iCode *newic = newiCode (DUMMY_READ_VOLATILE, NULL, IC_LEFT (ic));
1248 IC_RESULT (newic) = IC_LEFT (ic);
1249 newic->lineno = ic->lineno;
1250 addiCodeToeBBlock (ebp, newic, ic->next);
1253 IC_LEFT (ic) = NULL;
1254 SET_RESULT_RIGHT (ic);
1261 /* if both operands are equal */
1262 /* if yes turn it into 0 assignment */
1263 if (isOperandEqual (IC_LEFT (ic), IC_RIGHT (ic)))
1265 if (IS_OP_VOLATILE (IC_LEFT (ic)))
1267 iCode *newic = newiCode (DUMMY_READ_VOLATILE, NULL, IC_LEFT (ic));
1268 IC_RESULT (newic) = IC_LEFT (ic);
1269 newic->lineno = ic->lineno;
1270 addiCodeToeBBlock (ebp, newic, ic->next);
1272 newic = newiCode (DUMMY_READ_VOLATILE, NULL, IC_LEFT (ic));
1273 IC_RESULT (newic) = IC_LEFT (ic);
1274 newic->lineno = ic->lineno;
1275 addiCodeToeBBlock (ebp, newic, ic->next);
1278 IC_RIGHT (ic) = operandFromLit (0);
1279 IC_LEFT (ic) = NULL;
1280 SET_RESULT_RIGHT (ic);
1283 /* swap literal to right ic */
1284 if (IS_OP_LITERAL (IC_LEFT (ic)))
1289 IC_LEFT (ic) = IC_RIGHT (ic);
1292 /* if XOR then check if one of them is a zero */
1293 /* if yes turn it into assignment */
1294 if (IS_OP_LITERAL (IC_RIGHT (ic)))
1296 if (operandLitValue (IC_RIGHT (ic)) == 0.0)
1299 IC_RIGHT (ic) = IC_LEFT (ic);
1300 IC_LEFT (ic) = NULL;
1301 SET_RESULT_RIGHT (ic);
1310 #define OTHERS_PARM(s) (s->_isparm && !s->ismyparm)
1311 /*-----------------------------------------------------------------*/
1312 /* updateSpillLocation - keeps track of register spill location */
1313 /*-----------------------------------------------------------------*/
1315 updateSpillLocation (iCode * ic, int induction)
1319 if (POINTER_SET (ic))
1326 /* for the form true_symbol := iTempNN */
1327 if (ASSIGN_ITEMP_TO_SYM (ic) &&
1328 !SPIL_LOC (IC_RIGHT (ic))) {
1330 setype = getSpec (operandType (IC_RESULT (ic)));
1332 if (!OP_SYMBOL(IC_RIGHT (ic))->noSpilLoc &&
1333 !IS_VOLATILE (setype) &&
1334 !IN_FARSPACE (SPEC_OCLS (setype)) &&
1335 !OTHERS_PARM (OP_SYMBOL (IC_RESULT (ic))))
1337 wassert(IS_SYMOP(IC_RESULT (ic)));
1338 wassert(IS_SYMOP(IC_RIGHT (ic)));
1339 SPIL_LOC (IC_RIGHT (ic)) =
1340 IC_RESULT (ic)->operand.symOperand;
1346 #if 0 /* this needs furthur investigation can save a lot of code */
1347 if (ASSIGN_SYM_TO_ITEMP(ic) &&
1348 !SPIL_LOC(IC_RESULT(ic))) {
1349 if (!OTHERS_PARM (OP_SYMBOL (IC_RIGHT (ic))))
1350 SPIL_LOC (IC_RESULT (ic)) =
1351 IC_RIGHT (ic)->operand.symOperand;
1354 if (ASSIGN_ITEMP_TO_ITEMP (ic)) {
1356 if (!SPIL_LOC (IC_RIGHT (ic)) &&
1357 !bitVectBitsInCommon (OP_DEFS (IC_RIGHT (ic)), OP_USES (IC_RESULT (ic))) &&
1358 OP_SYMBOL (IC_RESULT (ic))->isreqv) {
1360 setype = getSpec (operandType (IC_RESULT (ic)));
1362 if (!OP_SYMBOL(IC_RIGHT (ic))->noSpilLoc &&
1363 !IS_VOLATILE (setype) &&
1364 !IN_FARSPACE (SPEC_OCLS (setype)) &&
1365 !OTHERS_PARM (OP_SYMBOL (IC_RESULT (ic)))) {
1367 SPIL_LOC (IC_RIGHT (ic)) =
1368 SPIL_LOC (IC_RESULT (ic));
1369 OP_SYMBOL (IC_RIGHT (ic))->prereqv =
1370 OP_SYMBOL (IC_RESULT (ic))->prereqv;
1373 /* special case for inductions */
1375 OP_SYMBOL(IC_RIGHT(ic))->isreqv &&
1376 !OP_SYMBOL(IC_RESULT (ic))->noSpilLoc &&
1377 !SPIL_LOC(IC_RESULT(ic))) {
1378 SPIL_LOC (IC_RESULT (ic)) = SPIL_LOC (IC_RIGHT (ic));
1379 OP_SYMBOL (IC_RESULT (ic))->prereqv =
1380 OP_SYMBOL (IC_RIGHT (ic))->prereqv;
1384 /*-----------------------------------------------------------------*/
1385 /* setUsesDef - sets the uses def bitvector for a given operand */
1386 /*-----------------------------------------------------------------*/
1388 setUsesDefs (operand * op, bitVect * bdefs,
1389 bitVect * idefs, bitVect ** oud)
1391 /* compute the definitions alive at this point */
1392 bitVect *adefs = bitVectUnion (bdefs, idefs);
1394 /* of these definitions find the ones that are */
1395 /* for this operand */
1396 adefs = bitVectIntersect (adefs, OP_DEFS (op));
1398 /* these are the definitions that this operand can use */
1399 op->usesDefs = adefs;
1401 /* the out defs is an union */
1402 *oud = bitVectUnion (*oud, adefs);
1405 /*-----------------------------------------------------------------*/
1406 /* unsetDefsAndUses - clear this operation for the operands */
1407 /*-----------------------------------------------------------------*/
1409 unsetDefsAndUses (iCode * ic)
1411 if (ic->op == JUMPTABLE)
1414 /* take away this definition from the def chain of the */
1415 /* result & take away from use set of the operands */
1418 /* turn off def set */
1419 if (IS_SYMOP (IC_RESULT (ic)))
1421 if (!POINTER_SET (ic))
1422 bitVectUnSetBit (OP_DEFS (IC_RESULT (ic)), ic->key);
1424 bitVectUnSetBit (OP_USES (IC_RESULT (ic)), ic->key);
1426 /* turn off the useSet for the operands */
1427 if (IS_SYMOP (IC_LEFT (ic)))
1428 bitVectUnSetBit (OP_USES (IC_LEFT (ic)), ic->key);
1430 if (IS_SYMOP (IC_RIGHT (ic)))
1431 bitVectUnSetBit (OP_USES (IC_RIGHT (ic)), ic->key);
1434 /* must be ifx turn off the use */ if (IS_SYMOP (IC_COND (ic)))
1435 bitVectUnSetBit (OP_USES (IC_COND (ic)), ic->key);
1438 /*-----------------------------------------------------------------*/
1439 /* ifxOptimize - changes ifx conditions if it can */
1440 /*-----------------------------------------------------------------*/
1442 ifxOptimize (iCode * ic, set * cseSet,
1444 eBBlock * ebb, int *change,
1450 /* if the condition can be replaced */
1454 applyToSetFTrue (cseSet, findCheaperOp, IC_COND (ic), &pdop, 0);
1457 ReplaceOpWithCheaperOp(&IC_COND (ic), pdop);
1462 /* if the conditional is a literal then */
1463 if (IS_OP_LITERAL (IC_COND (ic)))
1466 if ((operandLitValue (IC_COND (ic)) != 0.0) && IC_TRUE (ic))
1469 /* change to a goto */
1471 IC_LABEL (ic) = IC_TRUE (ic);
1478 if (!operandLitValue (IC_COND (ic)) && IC_FALSE (ic))
1481 IC_LABEL (ic) = IC_FALSE (ic);
1487 /* then kill this if condition */
1488 remiCodeFromeBBlock (ebb, ic);
1492 /* now we need to recompute the control flow */
1493 /* since the control flow has changed */
1494 /* this is very expensive but it does not happen */
1495 /* too often, if it does happen then the user pays */
1497 computeControlFlow (ebbi);
1498 if (!options.lessPedantic) {
1499 werrorfl (ic->filename, ic->lineno, W_CONTROL_FLOW);
1504 /* if there is only one successor and that successor
1505 is the same one we are conditionally going to then
1506 we can remove this conditional statement */
1507 label = (IC_TRUE (ic) ? IC_TRUE (ic) : IC_FALSE (ic));
1508 if (elementsInSet (ebb->succList) == 1 &&
1509 isinSet (ebb->succList, eBBWithEntryLabel (ebbi, label)))
1512 if (!options.lessPedantic) {
1513 werrorfl (ic->filename, ic->lineno, W_CONTROL_FLOW);
1515 if (IS_OP_VOLATILE (IC_COND (ic)))
1517 IC_RIGHT (ic) = IC_COND (ic);
1518 IC_LEFT (ic) = NULL;
1519 IC_RESULT (ic) = NULL;
1520 ic->op = DUMMY_READ_VOLATILE;
1524 remiCodeFromeBBlock (ebb, ic);
1525 computeControlFlow (ebbi);
1531 /* if it remains an IFX the update the use Set */
1534 OP_USES(IC_COND (ic))=bitVectSetBit (OP_USES (IC_COND (ic)), ic->key);
1535 setUsesDefs (IC_COND (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
1537 else if (ic->op == DUMMY_READ_VOLATILE)
1539 OP_USES(IC_RIGHT (ic))=bitVectSetBit (OP_USES (IC_RIGHT (ic)), ic->key);
1540 setUsesDefs (IC_RIGHT (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
1545 /*-----------------------------------------------------------------*/
1546 /* diCodeForSym - finds the definiting instruction for a symbol */
1547 /*-----------------------------------------------------------------*/
1548 DEFSETFUNC (diCodeForSym)
1551 V_ARG (operand *, sym);
1552 V_ARG (iCode **, dic);
1554 /* if already found */
1558 /* if not if this is the defining iCode */
1559 if (sym->key == cdp->key)
1568 /*-----------------------------------------------------------------*/
1569 /* constFold - does some constant folding */
1570 /*-----------------------------------------------------------------*/
1572 constFold (iCode * ic, set * cseSet)
1576 /* this routine will change
1582 /* deal with only + & - */
1583 if (ic->op != '+' &&
1587 /* this check is a heuristic to prevent live ranges
1588 from becoming too long */
1589 if (IS_PTR (operandType (IC_RESULT (ic))))
1592 /* check if operation with a literal */
1593 if (!IS_OP_LITERAL (IC_RIGHT (ic)))
1596 /* check if we can find a definition for the
1598 if (!(applyToSet (cseSet, diCodeForSym, IC_LEFT (ic), &dic)))
1601 /* check that this is also a +/- */
1602 if (dic->op != '+' && dic->op != '-')
1605 /* with a literal */
1606 if (!IS_OP_LITERAL (IC_RIGHT (dic)))
1609 /* find the definition of the left operand
1610 of dic.then check if this defined with a
1611 get_pointer return 0 if the pointer size is
1612 less than 2 (MCS51 specific) */
1613 if (!(applyToSet (cseSet, diCodeForSym, IC_LEFT (dic), &ldic)))
1616 if (POINTER_GET (ldic) && getSize (operandType (IC_LEFT (ldic))) <= 1)
1619 /* it is if the operations are the same */
1620 /* the literal parts need to be added */
1621 IC_LEFT (ic) = operandFromOperand (IC_LEFT (dic));
1622 if (ic->op == dic->op)
1623 IC_RIGHT (ic) = operandFromLit (operandLitValue (IC_RIGHT (ic)) +
1624 operandLitValue (IC_RIGHT (dic)));
1626 IC_RIGHT (ic) = operandFromLit (operandLitValue (IC_RIGHT (ic)) -
1627 operandLitValue (IC_RIGHT (dic)));
1629 if (IS_ITEMP (IC_RESULT (ic)))
1631 SPIL_LOC (IC_RESULT (ic)) = NULL;
1632 OP_SYMBOL(IC_RESULT (ic))->noSpilLoc = 1;
1639 /*-----------------------------------------------------------------*/
1640 /* deleteGetPointers - called when a pointer is passed as parm */
1641 /* will delete from cseSet all get pointers computed from this */
1642 /* pointer. A simple ifOperandsHave is not good enough here */
1643 /*-----------------------------------------------------------------*/
1645 deleteGetPointers (set ** cseSet, set ** pss, operand * op, eBBlock * ebb)
1647 set *compItems = NULL;
1653 if (!*cseSet && !*pss)
1656 addSet (&compItems, op);
1658 /* Recursively find all items computed from this operand .
1659 This done fairly simply go thru the list and find
1660 those that are computed by arthimetic with these
1662 /* Also check for those computed from our computed
1663 list . This will take care of situations like
1664 iTemp1 = iTemp0 + 8;
1665 iTemp2 = iTemp1 + 8; */
1669 for (cdp = setFirstItem (*cseSet); cdp; cdp = setNextItem (*cseSet))
1671 if (IS_ARITHMETIC_OP (cdp->diCode) || POINTER_GET(cdp->diCode))
1673 if (isinSetWith (compItems, (void*)IC_LEFT (cdp->diCode),
1674 (insetwithFunc)isOperandEqual) ||
1675 isinSetWith (compItems, (void*)IC_RIGHT (cdp->diCode),
1676 (insetwithFunc)isOperandEqual))
1678 if (!isinSetWith (compItems, (void*)IC_RESULT (cdp->diCode),
1679 (insetwithFunc)isOperandEqual))
1681 addSet (&compItems, IC_RESULT (cdp->diCode));
1690 /* now for the computed items */
1691 for (cop = setFirstItem (compItems); cop; cop = setNextItem (compItems))
1693 ebb->ptrsSet = bitVectSetBit (ebb->ptrsSet, cop->key);
1694 deleteItemIf (cseSet, ifPointerGet, cop);
1695 deleteItemIf (cseSet, ifDefSymIsX, cop);
1696 deleteItemIf (pss, ifPointerSet, cop);
1700 /*-----------------------------------------------------------------*/
1701 /* delGetPointerSucc - delete get pointer from inExprs of succ with */
1702 /* dfnum > supplied */
1703 /*-----------------------------------------------------------------*/
1704 DEFSETFUNC (delGetPointerSucc)
1706 eBBlock *ebp = item;
1707 V_ARG (operand *, op);
1714 if (ebp->dfnum > dfnum)
1716 deleteItemIf (&ebp->inExprs, ifPointerGet, op);
1719 return applyToSet (ebp->succList, delGetPointerSucc, op, dfnum);
1722 /*-----------------------------------------------------------------*/
1723 /* fixUpTypes - KLUGE HACK fixup a lowering problem */
1724 /*-----------------------------------------------------------------*/
1726 fixUpTypes (iCode * ic)
1728 sym_link *t1 = operandType (IC_LEFT (ic)), *t2;
1730 /* if (TARGET_IS_DS390) */
1731 if (options.model == MODEL_FLAT24)
1737 /* for pointer_gets if the types of result & left r the
1738 same then change it type of result to next */
1740 compareType (t2 = operandType (IC_RESULT (ic)), t1) == 1)
1742 setOperandType (IC_RESULT (ic), t2->next);
1746 /*-----------------------------------------------------------------*/
1747 /* isSignedOp - will return 1 if sign is important to operation */
1748 /*-----------------------------------------------------------------*/
1749 static int isSignedOp (iCode *ic)
1770 case GET_VALUE_AT_ADDRESS:
1801 dumpCseSet(set *cseSet)
1805 cseDef *item=cseSet->item;
1807 printOperand (item->sym, NULL);
1809 piCode (item->diCode, NULL);
1810 cseSet = cseSet->next;
1815 /*-----------------------------------------------------------------*/
1816 /* cseBBlock - common subexpression elimination for basic blocks */
1817 /* this is the hackiest kludgiest routine in the whole */
1818 /* system. also the most important, since almost all */
1819 /* data flow related information is computed by it */
1820 /*-----------------------------------------------------------------*/
1822 cseBBlock (eBBlock * ebb, int computeOnly,
1825 eBBlock ** ebbs = ebbi->bbOrder;
1826 int count = ebbi->count;
1831 set *ptrSetSet = NULL;
1834 /* if this block is not reachable */
1838 /* set of common subexpressions */
1839 cseSet = setFromSet (ebb->inExprs);
1841 /* these will be computed by this routine */
1842 setToNull ((void *) &ebb->outDefs);
1843 setToNull ((void *) &ebb->defSet);
1844 setToNull ((void *) &ebb->usesDefs);
1845 setToNull ((void *) &ebb->ptrsSet);
1846 setToNull ((void *) &ebb->addrOf);
1847 setToNull ((void *) &ebb->ldefs);
1849 ebb->outDefs = bitVectCopy (ebb->inDefs);
1850 bitVectDefault = iCodeKey;
1851 ebb->defSet = newBitVect (iCodeKey);
1852 ebb->usesDefs = newBitVect (iCodeKey);
1854 /* for all the instructions in this block do */
1855 for (ic = ebb->sch; ic; ic = ic->next)
1862 ic->eBBlockNum = ebb->bbnum;
1867 /* if this is an assignment from true symbol
1868 to a temp then do pointer post inc/dec optimzation */
1869 if (ic->op == '=' && !POINTER_SET (ic) &&
1870 IS_PTR (operandType (IC_RESULT (ic))))
1872 ptrPostIncDecOpt (ic);
1875 /* clear the def & use chains for the operands involved */
1876 /* in this operation . since it can change due to opts */
1877 unsetDefsAndUses (ic);
1879 if (ic->op == PCALL || ic->op == CALL || ic->op == RECEIVE)
1881 /* add to defSet of the symbol */
1882 OP_DEFS(IC_RESULT (ic))=
1883 bitVectSetBit (OP_DEFS (IC_RESULT (ic)), ic->key);
1884 /* add to the definition set of this block */
1885 ebb->defSet = bitVectSetBit (ebb->defSet, ic->key);
1886 ebb->ldefs = bitVectSetBit (ebb->ldefs, ic->key);
1887 ebb->outDefs = bitVectCplAnd (ebb->outDefs, OP_DEFS (IC_RESULT (ic)));
1888 setUsesDefs (IC_RESULT (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
1889 /* delete global variables from the cseSet
1890 since they can be modified by the function call */
1891 deleteItemIf (&cseSet, ifDefGlobal);
1893 /* and also iTemps derived from globals */
1894 deleteItemIf (&cseSet, ifFromGlobal);
1896 /* Delete iTemps derived from symbols whose address */
1897 /* has been taken */
1898 deleteItemIf (&cseSet, ifFromAddrTaken);
1900 /* delete all getpointer iCodes from cseSet, this should
1901 be done only for global arrays & pointers but at this
1902 point we don't know if globals, so to be safe do all */
1903 deleteItemIf (&cseSet, ifAnyGetPointer);
1905 /* can't cache pointer set/get operations across a call */
1906 deleteSet (&ptrSetSet);
1909 /* for pcall & ipush we need to add to the useSet */
1910 if ((ic->op == PCALL ||
1914 IS_SYMOP (IC_LEFT (ic)))
1917 /* check if they can be replaced */
1921 applyToSetFTrue (cseSet, findCheaperOp, IC_LEFT (ic), &pdop, 0);
1923 ReplaceOpWithCheaperOp(&IC_LEFT(ic), pdop);
1925 /* the lookup could have changed it */
1926 if (IS_SYMOP (IC_LEFT (ic)))
1928 OP_USES(IC_LEFT (ic))=
1929 bitVectSetBit (OP_USES (IC_LEFT (ic)), ic->key);
1930 setUsesDefs (IC_LEFT (ic), ebb->defSet,
1931 ebb->outDefs, &ebb->usesDefs);
1935 /* if we a sending a pointer as a parameter
1936 then kill all cse since the pointed to item
1937 might be changed in the function being called */
1938 if ((ic->op == IPUSH || ic->op == SEND) &&
1939 IS_PTR (operandType (IC_LEFT (ic))))
1941 deleteGetPointers (&cseSet, &ptrSetSet, IC_LEFT (ic), ebb);
1942 ebb->ptrsSet = bitVectSetBit (ebb->ptrsSet, IC_LEFT (ic)->key);
1943 for (i = 0; i < count; ebbs[i++]->visited = 0);
1944 applyToSet (ebb->succList, delGetPointerSucc,
1945 IC_LEFT (ic), ebb->dfnum);
1950 /* if jumptable then mark the usage */
1951 if (ic->op == JUMPTABLE)
1953 if (IS_SYMOP (IC_JTCOND (ic)))
1955 OP_USES(IC_JTCOND (ic)) =
1956 bitVectSetBit (OP_USES (IC_JTCOND (ic)), ic->key);
1957 setUsesDefs (IC_JTCOND (ic), ebb->defSet,
1958 ebb->outDefs, &ebb->usesDefs);
1968 /* do some algebraic optimizations if possible */
1969 algebraicOpts (ic, ebb);
1970 while (constFold (ic, cseSet));
1974 if (POINTER_GET (ic))
1976 if (!IS_PTR (operandType (IC_LEFT (ic))))
1978 setOperandType (IC_LEFT (ic),
1979 aggrToPtr (operandType (IC_LEFT (ic)), FALSE));
1980 IC_LEFT (ic)->aggr2ptr = 0;
1983 else if (IC_LEFT (ic)->aggr2ptr == 1)
1984 {/* band aid for kludge */
1985 setOperandType (IC_LEFT (ic),
1986 aggrToPtr (operandType (IC_LEFT (ic)), TRUE));
1987 IC_LEFT (ic)->aggr2ptr++;
1992 if (POINTER_SET (ic))
1994 if (!IS_PTR (operandType (IC_RESULT (ic))))
1996 setOperandType (IC_RESULT (ic),
1997 aggrToPtr (operandType (IC_RESULT (ic)), FALSE));
1998 IC_RESULT (ic)->aggr2ptr = 0;
2000 else if (IC_RESULT (ic)->aggr2ptr == 1)
2001 {/* band aid for kludge */
2002 setOperandType (IC_RESULT (ic),
2003 aggrToPtr (operandType (IC_RESULT (ic)), TRUE));
2004 IC_RESULT (ic)->aggr2ptr++;
2008 /* if this is a condition statement then */
2009 /* check if the condition can be replaced */
2012 ifxOptimize (ic, cseSet, computeOnly,
2018 /* if the assignment & result is a temp */
2019 /* see if we can replace it */
2020 if (!computeOnly && ic->op == '=')
2023 /* update the spill location for this */
2024 updateSpillLocation (ic,0);
2026 if (POINTER_SET (ic) && IS_SYMOP (IC_RESULT (ic)) &&
2027 !(IS_BITFIELD (OP_SYMBOL (IC_RESULT (ic))->etype)))
2030 applyToSetFTrue (cseSet, findCheaperOp, IC_RESULT (ic), &pdop, 0);
2031 if (pdop && !computeOnly && IS_ITEMP (pdop))
2033 ReplaceOpWithCheaperOp (&IC_RESULT(ic), pdop);
2034 if (!IS_PTR (operandType (IC_RESULT (ic))))
2036 setOperandType (IC_RESULT (ic),
2037 aggrToPtr (operandType (IC_RESULT (ic)), FALSE));
2043 checkSign = isSignedOp(ic);
2045 /* do the operand lookup i.e. for both the */
2046 /* right & left operand : check the cseSet */
2047 /* to see if they have been replaced if yes */
2048 /* then replace them with those from cseSet */
2050 /* and left is a symbol */
2051 if (IS_SYMOP (IC_LEFT (ic)) &&
2052 !IS_BITFIELD (OP_SYM_ETYPE (IC_LEFT (ic))) &&
2053 !computeOnly && ic->op != ADDRESS_OF)
2057 applyToSetFTrue (cseSet, findCheaperOp, IC_LEFT (ic), &pdop, checkSign);
2060 if (POINTER_GET (ic))
2062 if (IS_ITEMP (pdop) || IS_OP_LITERAL (pdop))
2064 /* some non dominating block does POINTER_SET with
2065 this variable .. unsafe to remove any POINTER_GETs */
2066 if (bitVectBitValue(ebb->ndompset,IC_LEFT(ic)->key))
2067 ebb->ptrsSet = bitVectSetBit(ebb->ptrsSet,pdop->key);
2068 ReplaceOpWithCheaperOp(&IC_LEFT(ic), pdop);
2071 /* check if there is a pointer set
2072 for the same pointer visible if yes
2073 then change this into an assignment */
2075 if (applyToSetFTrue (cseSet, findPointerSet, IC_LEFT (ic), &pdop, IC_RESULT (ic)) &&
2076 !bitVectBitValue (ebb->ptrsSet, pdop->key))
2079 IC_LEFT (ic) = NULL;
2080 ReplaceOpWithCheaperOp(&IC_RIGHT(ic), pdop);
2081 SET_ISADDR (IC_RESULT (ic), 0);
2087 ReplaceOpWithCheaperOp(&IC_LEFT(ic), pdop);
2094 if (IS_SYMOP (IC_RIGHT (ic)) && !computeOnly)
2098 applyToSetFTrue (cseSet, findCheaperOp, IC_RIGHT (ic), &pdop, checkSign);
2100 ReplaceOpWithCheaperOp(&IC_RIGHT(ic), pdop);
2105 /* if left or right changed then do algebraic */
2106 if (!computeOnly && change)
2108 algebraicOpts (ic, ebb);
2109 while (constFold (ic, cseSet));
2112 /* if after all this it becomes an assignment to self
2113 then delete it and continue */
2114 if (ASSIGNMENT_TO_SELF (ic) && !isOperandVolatile (IC_RIGHT(ic), FALSE))
2116 remiCodeFromeBBlock (ebb, ic);
2120 /* now we will check to see if the entire */
2121 /* operation has been performed before */
2122 /* and is available */
2123 /* don't do assignments they will be killed */
2124 /* by dead code elimination if required do */
2125 /* it only if result is a temporary */
2127 if (!(POINTER_GET (ic) &&
2128 (IS_BITFIELD (OP_SYMBOL (IC_RESULT (ic))->etype) ||
2129 isOperandVolatile (IC_LEFT (ic), TRUE) ||
2130 bitVectBitValue (ebb->ndompset, IC_LEFT (ic)->key))) &&
2132 IS_ITEMP (IC_RESULT (ic)) &&
2135 applyToSet (cseSet, findPrevIc, ic, &pdic);
2136 if (pdic && compareType (operandType (IC_RESULT (pdic)),
2137 operandType (IC_RESULT (ic))) != 1)
2139 if (pdic && port->cseOk && (*port->cseOk)(ic,pdic) == 0)
2143 /* Alternate code */
2144 if (pdic && IS_ITEMP(IC_RESULT(ic))) {
2145 if (POINTER_GET(ic) && bitVectBitValue(ebb->ptrsSet,IC_LEFT(ic)->key)) {
2146 /* Mmm, found an equivalent pointer get at a lower level.
2147 This could be a loop however with the same pointer set
2150 /* if previous definition found change this to an assignment */
2153 IC_RIGHT(ic) = operandFromOperand(IC_RESULT(pdic));
2154 SET_ISADDR(IC_RESULT(ic),0);
2155 SET_ISADDR(IC_RIGHT (ic),0);
2159 if (!(POINTER_SET (ic)) && IC_RESULT (ic)) {
2161 deleteItemIf (&cseSet, ifDefSymIsX, IC_RESULT (ic));
2162 csed = newCseDef (IC_RESULT (ic), ic);
2163 updateCseDefAncestors (csed, cseSet);
2164 addSetHead (&cseSet, csed);
2168 /* if assignment to a parameter which is not
2169 mine and type is a pointer then delete
2170 pointerGets to take care of aliasing */
2171 if (ASSIGNMENT (ic) &&
2172 IS_SYMOP (IC_RESULT (ic)) &&
2173 OTHERS_PARM (OP_SYMBOL (IC_RESULT (ic))) &&
2174 IS_PTR (operandType (IC_RESULT (ic))))
2176 deleteGetPointers (&cseSet, &ptrSetSet, IC_RIGHT (ic), ebb);
2177 for (i = 0; i < count; ebbs[i++]->visited = 0);
2178 applyToSet (ebb->succList, delGetPointerSucc, IC_RIGHT (ic), ebb->dfnum);
2179 ebb->ptrsSet = bitVectSetBit (ebb->ptrsSet, IC_RIGHT (ic)->key);
2182 /* if this is a pointerget then see if we can replace
2183 this with a previously assigned pointer value */
2184 if (POINTER_GET (ic) &&
2185 !(IS_BITFIELD (OP_SYMBOL (IC_RESULT (ic))->etype) ||
2186 isOperandVolatile (IC_LEFT (ic), TRUE)))
2189 applyToSet (ptrSetSet, findPointerSet, IC_LEFT (ic), &pdop, IC_RESULT (ic));
2190 /* if we find it then locally replace all
2191 references to the result with what we assigned */
2194 replaceAllSymBySym (ic->next, IC_RESULT (ic), pdop, &ebb->ndompset);
2198 /* delete from the cseSet anything that has */
2199 /* operands matching the result of this */
2200 /* except in case of pointer access */
2201 if (!(POINTER_SET (ic)) && IS_SYMOP (IC_RESULT (ic)))
2203 deleteItemIf (&cseSet, ifOperandsHave, IC_RESULT (ic));
2204 /* delete any previous definitions */
2205 ebb->defSet = bitVectCplAnd (ebb->defSet, OP_DEFS (IC_RESULT (ic)));
2208 /* add the left & right to the defUse set */
2209 if (IC_LEFT (ic) && IS_SYMOP (IC_LEFT (ic)))
2211 OP_USES(IC_LEFT (ic))=
2212 bitVectSetBit (OP_USES (IC_LEFT (ic)), ic->key);
2213 setUsesDefs (IC_LEFT (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
2216 if (IC_RIGHT (ic) && IS_SYMOP (IC_RIGHT (ic)))
2218 OP_USES(IC_RIGHT (ic))=
2219 bitVectSetBit (OP_USES (IC_RIGHT (ic)), ic->key);
2220 setUsesDefs (IC_RIGHT (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
2223 /* for the result it is special case, put the result */
2224 /* in the defuseSet if it a pointer or array access */
2225 if (POINTER_SET (defic) && IS_SYMOP (IC_RESULT (ic)))
2227 OP_USES(IC_RESULT (ic))=
2228 bitVectSetBit (OP_USES (IC_RESULT (ic)), ic->key);
2229 setUsesDefs (IC_RESULT (ic), ebb->defSet, ebb->outDefs, &ebb->usesDefs);
2230 deleteItemIf (&cseSet, ifPointerGet, IC_RESULT (ic));
2231 ebb->ptrsSet = bitVectSetBit (ebb->ptrsSet, IC_RESULT (ic)->key);
2232 /* delete from inexpressions of all successors which
2233 have dfNum > than this block */
2234 for (i = 0; i < count; ebbs[i++]->visited = 0);
2235 applyToSet (ebb->succList, delGetPointerSucc, IC_RESULT (ic), ebb->dfnum);
2237 /* delete from cseSet all other pointer sets
2239 deleteItemIf (&ptrSetSet, ifPointerSet, IC_RESULT (ic));
2240 /* add to the local pointerset set */
2241 addSetHead (&ptrSetSet, newCseDef (IC_RESULT (ic), ic));
2245 /* add the result to definition set */
2246 if (IS_SYMOP (IC_RESULT (ic)))
2248 OP_DEFS(IC_RESULT (ic))=
2249 bitVectSetBit (OP_DEFS (IC_RESULT (ic)), ic->key);
2250 ebb->defSet = bitVectSetBit (ebb->defSet, ic->key);
2251 ebb->outDefs = bitVectCplAnd (ebb->outDefs, OP_DEFS (IC_RESULT (ic)));
2252 ebb->ldefs = bitVectSetBit (ebb->ldefs, ic->key);
2256 /* if this is an addressof instruction then */
2257 /* put the symbol in the address of list & */
2258 /* delete it from the cseSet */
2259 if (defic->op == ADDRESS_OF)
2261 addSetHead (&ebb->addrOf, IC_LEFT (ic));
2262 deleteItemIf (&cseSet, ifDefSymIsX, IC_LEFT (ic));
2266 for (expr=setFirstItem (ebb->inExprs); expr; expr=setNextItem (ebb->inExprs))
2267 if (!isinSetWith (cseSet, expr, isCseDefEqual) &&
2268 !isinSetWith (ebb->killedExprs, expr, isCseDefEqual)) {
2269 addSetHead (&ebb->killedExprs, expr);
2271 setToNull ((void *) &ebb->outExprs);
2272 ebb->outExprs = cseSet;
2273 ebb->outDefs = bitVectUnion (ebb->outDefs, ebb->defSet);
2274 ebb->ptrsSet = bitVectUnion (ebb->ptrsSet, ebb->inPtrsSet);
2278 /*-----------------------------------------------------------------*/
2279 /* cseAllBlocks - will sequentially go thru & do cse for all blocks */
2280 /*-----------------------------------------------------------------*/
2282 cseAllBlocks (ebbIndex * ebbi, int computeOnly)
2284 eBBlock ** ebbs = ebbi->dfOrder;
2285 int count = ebbi->count;
2289 /* if optimization turned off */
2291 for (i = 0; i < count; i++)
2292 change += cseBBlock (ebbs[i], computeOnly, ebbi);