1 /*------------------------------------------------------------------------
3 SDCCralloc.c - source file for register allocation. (8051) specific
5 Written By - Sandeep Dutta . sandeep.dutta@usa.net (1998)
7 This program is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 2, or (at your option) any
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21 In other words, you are welcome to use, share and improve this program.
22 You are forbidden to forbid anyone else to use, share and improve
23 what you give them. Help stamp out software-hoarding!
24 -------------------------------------------------------------------------*/
30 /*-----------------------------------------------------------------*/
31 /* At this point we start getting processor specific although */
32 /* some routines are non-processor specific & can be reused when */
33 /* targetting other processors. The decision for this will have */
34 /* to be made on a routine by routine basis */
35 /* routines used to pack registers are most definitely not reusable */
36 /* since the pack the registers depending strictly on the MCU */
37 /*-----------------------------------------------------------------*/
47 bitVect *totRegAssigned; /* final set of LRs that got into registers */
50 bitVect *funcrUsed; /* registers used in a function */
56 /* Shared with gen.c */
57 int ds390_ptrRegReq; /* one byte pointer register required */
63 {REG_GPR, R2_IDX, REG_GPR, "r2", "ar2", "0", 2, 1, 1},
64 {REG_GPR, R3_IDX, REG_GPR, "r3", "ar3", "0", 3, 1, 1},
65 {REG_GPR, R4_IDX, REG_GPR, "r4", "ar4", "0", 4, 1, 1},
66 {REG_GPR, R5_IDX, REG_GPR, "r5", "ar5", "0", 5, 1, 1},
67 {REG_GPR, R6_IDX, REG_GPR, "r6", "ar6", "0", 6, 1, 1},
68 {REG_GPR, R7_IDX, REG_GPR, "r7", "ar7", "0", 7, 1, 1},
69 {REG_PTR, R0_IDX, REG_PTR, "r0", "ar0", "0", 0, 1, 1},
70 {REG_PTR, R1_IDX, REG_PTR, "r1", "ar1", "0", 1, 1, 1},
71 {REG_GPR, DPL_IDX, REG_GPR, "dpl", "dpl", "dpl", 0, 0, 0},
72 {REG_GPR, DPH_IDX, REG_GPR, "dph", "dph", "dph", 0, 0, 0},
73 {REG_GPR, DPX_IDX, REG_GPR, "dpx", "dpx", "dpx", 0, 0, 0},
74 {REG_GPR, B_IDX, REG_GPR, "b", "b", "b", 0, 0, 0},
75 {REG_GPR, X8_IDX, REG_GPR, "x8", "x8", "xreg", 0, 0, 0},
76 {REG_GPR, X9_IDX, REG_GPR, "x9", "x9", "xreg", 1, 0, 0},
77 {REG_GPR, X10_IDX, REG_GPR, "x10", "x10", "xreg", 2, 0, 0},
78 {REG_GPR, X11_IDX, REG_GPR, "x11", "x11", "xreg", 3, 0, 0},
79 {REG_GPR, X12_IDX, REG_GPR, "x12", "x12", "xreg", 4, 0, 0},
80 {REG_CND, CND_IDX, REG_GPR, "C", "C", "xreg", 0, 0, 0},
83 static void spillThis (symbol *);
84 static void freeAllRegs ();
85 static iCode * packRegsDPTRuse (operand *);
87 /*-----------------------------------------------------------------*/
88 /* allocReg - allocates register of given type */
89 /*-----------------------------------------------------------------*/
95 for (i = 0; i < ds390_nRegs; i++)
98 /* if type is given as 0 then any
99 free register will do */
103 regs390[i].isFree = 0;
106 bitVectSetBit (currFunc->regsUsed, i);
109 /* other wise look for specific type
111 if (regs390[i].isFree &&
112 regs390[i].type == type)
114 regs390[i].isFree = 0;
117 bitVectSetBit (currFunc->regsUsed, i);
124 /*-----------------------------------------------------------------*/
125 /* ds390_regWithIdx - returns pointer to register wit index number */
126 /*-----------------------------------------------------------------*/
128 ds390_regWithIdx (int idx)
132 for (i = 0; i < ds390_nRegs; i++)
133 if (regs390[i].rIdx == idx)
136 werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
137 "regWithIdx not found");
141 /*-----------------------------------------------------------------*/
142 /* freeReg - frees a register */
143 /*-----------------------------------------------------------------*/
150 /*-----------------------------------------------------------------*/
151 /* useReg - marks a register as used */
152 /*-----------------------------------------------------------------*/
160 /*-----------------------------------------------------------------*/
161 /* nFreeRegs - returns number of free registers */
162 /*-----------------------------------------------------------------*/
169 for (i = 0; i < ds390_nRegs; i++)
170 if (regs390[i].isFree && regs390[i].type == type)
175 /*-----------------------------------------------------------------*/
176 /* nfreeRegsType - free registers with type */
177 /*-----------------------------------------------------------------*/
179 nfreeRegsType (int type)
184 if ((nfr = nFreeRegs (type)) == 0)
185 return nFreeRegs (REG_GPR);
188 return nFreeRegs (type);
192 /*-----------------------------------------------------------------*/
193 /* allDefsOutOfRange - all definitions are out of a range */
194 /*-----------------------------------------------------------------*/
196 allDefsOutOfRange (bitVect * defs, int fseq, int toseq)
203 for (i = 0; i < defs->size; i++)
207 if (bitVectBitValue (defs, i) &&
208 (ic = hTabItemWithKey (iCodehTab, i)) &&
209 (ic->seq >= fseq && ic->seq <= toseq))
218 /*-----------------------------------------------------------------*/
219 /* isOperandInReg - returns true if operand is currently in regs */
220 /*-----------------------------------------------------------------*/
221 static int isOperandInReg(operand *op)
223 if (!IS_SYMOP(op)) return 0;
225 return bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(op)->key);
228 /*-----------------------------------------------------------------*/
229 /* computeSpillable - given a point find the spillable live ranges */
230 /*-----------------------------------------------------------------*/
232 computeSpillable (iCode * ic)
236 /* spillable live ranges are those that are live at this
237 point . the following categories need to be subtracted
239 a) - those that are already spilt
240 b) - if being used by this one
241 c) - defined by this one */
243 spillable = bitVectCopy (ic->rlive);
245 bitVectCplAnd (spillable, _G.spiltSet); /* those already spilt */
247 bitVectCplAnd (spillable, ic->uses); /* used in this one */
248 bitVectUnSetBit (spillable, ic->defKey);
249 spillable = bitVectIntersect (spillable, _G.regAssigned);
254 /*-----------------------------------------------------------------*/
255 /* noSpilLoc - return true if a variable has no spil location */
256 /*-----------------------------------------------------------------*/
258 noSpilLoc (symbol * sym, eBBlock * ebp, iCode * ic)
260 return (sym->usl.spillLoc ? 0 : 1);
263 /*-----------------------------------------------------------------*/
264 /* hasSpilLoc - will return 1 if the symbol has spil location */
265 /*-----------------------------------------------------------------*/
267 hasSpilLoc (symbol * sym, eBBlock * ebp, iCode * ic)
269 return (sym->usl.spillLoc ? 1 : 0);
272 /*-----------------------------------------------------------------*/
273 /* directSpilLoc - will return 1 if the splilocation is in direct */
274 /*-----------------------------------------------------------------*/
276 directSpilLoc (symbol * sym, eBBlock * ebp, iCode * ic)
278 if (sym->usl.spillLoc &&
279 (IN_DIRSPACE (SPEC_OCLS (sym->usl.spillLoc->etype))))
285 /*-----------------------------------------------------------------*/
286 /* hasSpilLocnoUptr - will return 1 if the symbol has spil location */
287 /* but is not used as a pointer */
288 /*-----------------------------------------------------------------*/
290 hasSpilLocnoUptr (symbol * sym, eBBlock * ebp, iCode * ic)
292 return ((sym->usl.spillLoc && !sym->uptr) ? 1 : 0);
295 /*-----------------------------------------------------------------*/
296 /* rematable - will return 1 if the remat flag is set */
297 /*-----------------------------------------------------------------*/
299 rematable (symbol * sym, eBBlock * ebp, iCode * ic)
304 /*-----------------------------------------------------------------*/
305 /* notUsedInBlock - not used in this block */
306 /*-----------------------------------------------------------------*/
308 notUsedInBlock (symbol * sym, eBBlock * ebp, iCode * ic)
310 return (!bitVectBitsInCommon (sym->defs, ebp->usesDefs) &&
311 allDefsOutOfRange (sym->defs, ebp->fSeq, ebp->lSeq));
312 /* return (!bitVectBitsInCommon(sym->defs,ebp->usesDefs)); */
315 /*-----------------------------------------------------------------*/
316 /* notUsedInRemaining - not used or defined in remain of the block */
317 /*-----------------------------------------------------------------*/
319 notUsedInRemaining (symbol * sym, eBBlock * ebp, iCode * ic)
321 return ((usedInRemaining (operandFromSymbol (sym), ic) ? 0 : 1) &&
322 allDefsOutOfRange (sym->defs, ebp->fSeq, ebp->lSeq));
325 /*-----------------------------------------------------------------*/
326 /* allLRs - return true for all */
327 /*-----------------------------------------------------------------*/
329 allLRs (symbol * sym, eBBlock * ebp, iCode * ic)
334 /*-----------------------------------------------------------------*/
335 /* liveRangesWith - applies function to a given set of live range */
336 /*-----------------------------------------------------------------*/
338 liveRangesWith (bitVect * lrs, int (func) (symbol *, eBBlock *, iCode *),
339 eBBlock * ebp, iCode * ic)
344 if (!lrs || !lrs->size)
347 for (i = 1; i < lrs->size; i++)
350 if (!bitVectBitValue (lrs, i))
353 /* if we don't find it in the live range
354 hash table we are in serious trouble */
355 if (!(sym = hTabItemWithKey (liveRanges, i)))
357 werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
358 "liveRangesWith could not find liveRange");
362 if (func (sym, ebp, ic) && bitVectBitValue (_G.regAssigned, sym->key))
363 addSetHead (&rset, sym);
370 /*-----------------------------------------------------------------*/
371 /* leastUsedLR - given a set determines which is the least used */
372 /*-----------------------------------------------------------------*/
374 leastUsedLR (set * sset)
376 symbol *sym = NULL, *lsym = NULL;
378 sym = lsym = setFirstItem (sset);
383 for (; lsym; lsym = setNextItem (sset))
386 /* if usage is the same then prefer
387 the spill the smaller of the two */
388 if (lsym->used == sym->used)
389 if (getSize (lsym->type) < getSize (sym->type))
393 if (lsym->used < sym->used)
398 setToNull ((void **) &sset);
403 /*-----------------------------------------------------------------*/
404 /* noOverLap - will iterate through the list looking for over lap */
405 /*-----------------------------------------------------------------*/
407 noOverLap (set * itmpStack, symbol * fsym)
411 for (sym = setFirstItem (itmpStack); sym;
412 sym = setNextItem (itmpStack))
414 if (bitVectBitValue(sym->clashes,fsym->key)) return 0;
419 /*-----------------------------------------------------------------*/
420 /* isFree - will return 1 if the a free spil location is found */
421 /*-----------------------------------------------------------------*/
426 V_ARG (symbol **, sloc);
427 V_ARG (symbol *, fsym);
429 /* if already found */
433 /* if it is free && and the itmp assigned to
434 this does not have any overlapping live ranges
435 with the one currently being assigned and
436 the size can be accomodated */
438 noOverLap (sym->usl.itmpStack, fsym) &&
439 getSize (sym->type) >= getSize (fsym->type))
448 /*-----------------------------------------------------------------*/
449 /* spillLRWithPtrReg :- will spil those live ranges which use PTR */
450 /*-----------------------------------------------------------------*/
452 spillLRWithPtrReg (symbol * forSym)
458 if (!_G.regAssigned ||
459 bitVectIsZero (_G.regAssigned))
462 r0 = ds390_regWithIdx (R0_IDX);
463 r1 = ds390_regWithIdx (R1_IDX);
465 /* for all live ranges */
466 for (lrsym = hTabFirstItem (liveRanges, &k); lrsym;
467 lrsym = hTabNextItem (liveRanges, &k))
471 /* if no registers assigned to it or
473 /* if it does not overlap with this then
474 not need to spill it */
476 if (lrsym->isspilt || !lrsym->nRegs ||
477 (lrsym->liveTo < forSym->liveFrom))
480 /* go thru the registers : if it is either
481 r0 or r1 then spil it */
482 for (j = 0; j < lrsym->nRegs; j++)
483 if (lrsym->regs[j] == r0 ||
484 lrsym->regs[j] == r1)
493 /*-----------------------------------------------------------------*/
494 /* createStackSpil - create a location on the stack to spil */
495 /*-----------------------------------------------------------------*/
497 createStackSpil (symbol * sym)
500 int useXstack, model, noOverlay;
504 /* first go try and find a free one that is already
505 existing on the stack */
506 if (applyToSet (_G.stackSpil, isFree, &sloc, sym))
508 /* found a free one : just update & return */
509 sym->usl.spillLoc = sloc;
512 addSetHead (&sloc->usl.itmpStack, sym);
516 /* could not then have to create one , this is the hard part
517 we need to allocate this on the stack : this is really a
518 hack!! but cannot think of anything better at this time */
520 if (sprintf (slocBuffer, "sloc%d", _G.slocNum++) >= sizeof (slocBuffer))
522 fprintf (stderr, "***Internal error: slocBuffer overflowed: %s:%d\n",
527 sloc = newiTemp (slocBuffer);
529 /* set the type to the spilling symbol */
530 sloc->type = copyLinkChain (sym->type);
531 sloc->etype = getSpec (sloc->type);
532 if (options.model == MODEL_SMALL) {
533 SPEC_SCLS (sloc->etype) = S_DATA;
535 SPEC_SCLS (sloc->etype) = S_XDATA;
537 SPEC_EXTR (sloc->etype) = 0;
538 SPEC_STAT (sloc->etype) = 0;
539 SPEC_VOLATILE(sloc->etype) = 0;
541 /* we don't allow it to be allocated`
542 onto the external stack since : so we
543 temporarily turn it off ; we also
544 turn off memory model to prevent
545 the spil from going to the external storage
546 and turn off overlaying
549 useXstack = options.useXstack;
550 model = options.model;
551 noOverlay = options.noOverlay;
552 options.noOverlay = 1;
554 /* options.model = options.useXstack = 0; */
558 options.useXstack = useXstack;
559 options.model = model;
560 options.noOverlay = noOverlay;
561 sloc->isref = 1; /* to prevent compiler warning */
563 /* if it is on the stack then update the stack */
564 if (IN_STACK (sloc->etype))
566 currFunc->stack += getSize (sloc->type);
567 _G.stackExtend += getSize (sloc->type);
570 _G.dataExtend += getSize (sloc->type);
572 /* add it to the _G.stackSpil set */
573 addSetHead (&_G.stackSpil, sloc);
574 sym->usl.spillLoc = sloc;
577 /* add it to the set of itempStack set
578 of the spill location */
579 addSetHead (&sloc->usl.itmpStack, sym);
583 /*-----------------------------------------------------------------*/
584 /* isSpiltOnStack - returns true if the spil location is on stack */
585 /*-----------------------------------------------------------------*/
587 isSpiltOnStack (symbol * sym)
597 /* if (sym->_G.stackSpil) */
600 if (!sym->usl.spillLoc)
603 etype = getSpec (sym->usl.spillLoc->type);
604 if (IN_STACK (etype))
610 /*-----------------------------------------------------------------*/
611 /* spillThis - spils a specific operand */
612 /*-----------------------------------------------------------------*/
614 spillThis (symbol * sym)
617 /* if this is rematerializable or has a spillLocation
618 we are okay, else we need to create a spillLocation
620 if (!(sym->remat || sym->usl.spillLoc))
621 createStackSpil (sym);
624 /* mark it has spilt & put it in the spilt set */
625 sym->isspilt = sym->spillA = 1;
626 _G.spiltSet = bitVectSetBit (_G.spiltSet, sym->key);
628 bitVectUnSetBit (_G.regAssigned, sym->key);
629 bitVectUnSetBit (_G.totRegAssigned, sym->key);
631 for (i = 0; i < sym->nRegs; i++)
635 freeReg (sym->regs[i]);
639 /* if spilt on stack then free up r0 & r1
640 if they could have been assigned to some
642 if (!ds390_ptrRegReq && isSpiltOnStack (sym))
644 ds390_ptrRegReq += !options.stack10bit;
645 spillLRWithPtrReg (sym);
648 if (sym->usl.spillLoc && !sym->remat)
649 sym->usl.spillLoc->allocreq++;
653 /*-----------------------------------------------------------------*/
654 /* selectSpil - select a iTemp to spil : rather a simple procedure */
655 /*-----------------------------------------------------------------*/
657 selectSpil (iCode * ic, eBBlock * ebp, symbol * forSym)
659 bitVect *lrcs = NULL;
663 /* get the spillable live ranges */
664 lrcs = computeSpillable (ic);
666 /* get all live ranges that are rematerizable */
667 if ((selectS = liveRangesWith (lrcs, rematable, ebp, ic)))
670 /* return the least used of these */
671 return leastUsedLR (selectS);
674 /* get live ranges with spillLocations in direct space */
675 if ((selectS = liveRangesWith (lrcs, directSpilLoc, ebp, ic)))
677 sym = leastUsedLR (selectS);
678 strcpy (sym->rname, (sym->usl.spillLoc->rname[0] ?
679 sym->usl.spillLoc->rname :
680 sym->usl.spillLoc->name));
682 /* mark it as allocation required */
683 sym->usl.spillLoc->allocreq++;
687 /* if the symbol is local to the block then */
688 if (forSym->liveTo < ebp->lSeq)
691 /* check if there are any live ranges allocated
692 to registers that are not used in this block */
693 if (!_G.blockSpil && (selectS = liveRangesWith (lrcs, notUsedInBlock, ebp, ic)))
695 sym = leastUsedLR (selectS);
696 /* if this is not rematerializable */
705 /* check if there are any live ranges that not
706 used in the remainder of the block */
707 if (!_G.blockSpil && (selectS = liveRangesWith (lrcs, notUsedInRemaining, ebp, ic)))
709 sym = leastUsedLR (selectS);
722 /* find live ranges with spillocation && not used as pointers */
723 if ((selectS = liveRangesWith (lrcs, hasSpilLocnoUptr, ebp, ic)))
726 sym = leastUsedLR (selectS);
727 /* mark this as allocation required */
728 sym->usl.spillLoc->allocreq++;
732 /* find live ranges with spillocation */
733 if ((selectS = liveRangesWith (lrcs, hasSpilLoc, ebp, ic)))
736 sym = leastUsedLR (selectS);
737 sym->usl.spillLoc->allocreq++;
741 /* couldn't find then we need to create a spil
742 location on the stack , for which one? the least
744 if ((selectS = liveRangesWith (lrcs, noSpilLoc, ebp, ic)))
747 /* return a created spil location */
748 sym = createStackSpil (leastUsedLR (selectS));
749 sym->usl.spillLoc->allocreq++;
753 /* this is an extreme situation we will spill
754 this one : happens very rarely but it does happen */
760 /*-----------------------------------------------------------------*/
761 /* spilSomething - spil some variable & mark registers as free */
762 /*-----------------------------------------------------------------*/
764 spilSomething (iCode * ic, eBBlock * ebp, symbol * forSym)
769 /* get something we can spil */
770 ssym = selectSpil (ic, ebp, forSym);
772 /* mark it as spilt */
773 ssym->isspilt = ssym->spillA = 1;
774 _G.spiltSet = bitVectSetBit (_G.spiltSet, ssym->key);
776 /* mark it as not register assigned &
777 take it away from the set */
778 bitVectUnSetBit (_G.regAssigned, ssym->key);
779 bitVectUnSetBit (_G.totRegAssigned, ssym->key);
781 /* mark the registers as free */
782 for (i = 0; i < ssym->nRegs; i++)
784 freeReg (ssym->regs[i]);
786 /* if spilt on stack then free up r0 & r1
787 if they could have been assigned to as gprs */
788 if (!ds390_ptrRegReq && isSpiltOnStack (ssym) && !options.stack10bit)
791 spillLRWithPtrReg (ssym);
794 /* if this was a block level spil then insert push & pop
795 at the start & end of block respectively */
798 iCode *nic = newiCode (IPUSH, operandFromSymbol (ssym), NULL);
799 /* add push to the start of the block */
800 addiCodeToeBBlock (ebp, nic, (ebp->sch->op == LABEL ?
801 ebp->sch->next : ebp->sch));
802 nic = newiCode (IPOP, operandFromSymbol (ssym), NULL);
803 /* add pop to the end of the block */
804 addiCodeToeBBlock (ebp, nic, NULL);
807 /* if spilt because not used in the remainder of the
808 block then add a push before this instruction and
809 a pop at the end of the block */
810 if (ssym->remainSpil)
813 iCode *nic = newiCode (IPUSH, operandFromSymbol (ssym), NULL);
814 /* add push just before this instruction */
815 addiCodeToeBBlock (ebp, nic, ic);
817 nic = newiCode (IPOP, operandFromSymbol (ssym), NULL);
818 /* add pop to the end of the block */
819 addiCodeToeBBlock (ebp, nic, NULL);
828 /*-----------------------------------------------------------------*/
829 /* getRegPtr - will try for PTR if not a GPR type if not spil */
830 /*-----------------------------------------------------------------*/
832 getRegPtr (iCode * ic, eBBlock * ebp, symbol * sym)
837 /* try for a ptr type */
838 if ((reg = allocReg (REG_PTR)))
841 /* try for gpr type */
842 if ((reg = allocReg (REG_GPR)))
845 /* we have to spil */
846 if (!spilSomething (ic, ebp, sym))
849 /* this looks like an infinite loop but
850 in really selectSpil will abort */
854 /*-----------------------------------------------------------------*/
855 /* getRegGpr - will try for GPR if not spil */
856 /*-----------------------------------------------------------------*/
858 getRegGpr (iCode * ic, eBBlock * ebp, symbol * sym)
863 /* try for gpr type */
864 if ((reg = allocReg (REG_GPR)))
867 if (!ds390_ptrRegReq)
868 if ((reg = allocReg (REG_PTR)))
871 /* we have to spil */
872 if (!spilSomething (ic, ebp, sym))
875 /* this looks like an infinite loop but
876 in really selectSpil will abort */
880 /*-----------------------------------------------------------------*/
881 /* getRegPtrNoSpil - get it cannot split */
882 /*-----------------------------------------------------------------*/
883 static regs *getRegPtrNoSpil()
887 /* try for a ptr type */
888 if ((reg = allocReg (REG_PTR)))
891 /* try for gpr type */
892 if ((reg = allocReg (REG_GPR)))
898 /*-----------------------------------------------------------------*/
899 /* getRegGprNoSpil - get it cannot split */
900 /*-----------------------------------------------------------------*/
901 static regs *getRegGprNoSpil()
905 if ((reg = allocReg (REG_GPR)))
908 if (!ds390_ptrRegReq)
909 if ((reg = allocReg (REG_PTR)))
915 /*-----------------------------------------------------------------*/
916 /* symHasReg - symbol has a given register */
917 /*-----------------------------------------------------------------*/
919 symHasReg (symbol * sym, regs * reg)
923 for (i = 0; i < sym->nRegs; i++)
924 if (sym->regs[i] == reg)
930 /*-----------------------------------------------------------------*/
931 /* deassignLRs - check the live to and if they have registers & are */
932 /* not spilt then free up the registers */
933 /*-----------------------------------------------------------------*/
935 deassignLRs (iCode * ic, eBBlock * ebp)
941 for (sym = hTabFirstItem (liveRanges, &k); sym;
942 sym = hTabNextItem (liveRanges, &k))
946 /* if it does not end here */
947 if (sym->liveTo > ic->seq)
950 /* if it was spilt on stack then we can
951 mark the stack spil location as free */
956 sym->usl.spillLoc->isFree = 1;
962 if (!bitVectBitValue (_G.regAssigned, sym->key))
965 /* special case check if this is an IFX &
966 the privious one was a pop and the
967 previous one was not spilt then keep track
969 if (ic->op == IFX && ic->prev &&
970 ic->prev->op == IPOP &&
971 !ic->prev->parmPush &&
972 !OP_SYMBOL (IC_LEFT (ic->prev))->isspilt)
973 psym = OP_SYMBOL (IC_LEFT (ic->prev));
979 bitVectUnSetBit (_G.regAssigned, sym->key);
981 /* if the result of this one needs registers
982 and does not have it then assign it right
984 if (IC_RESULT (ic) &&
985 !(SKIP_IC2 (ic) || /* not a special icode */
986 ic->op == JUMPTABLE ||
992 (result = OP_SYMBOL (IC_RESULT (ic))) && /* has a result */
993 result->liveTo > ic->seq && /* and will live beyond this */
994 result->liveTo <= ebp->lSeq && /* does not go beyond this block */
995 result->regType == sym->regType && /* same register types */
996 result->nRegs && /* which needs registers */
997 !result->isspilt && /* and does not already have them */
999 !bitVectBitValue (_G.regAssigned, result->key) &&
1000 /* the number of free regs + number of regs in this LR
1001 can accomodate the what result Needs */
1002 ((nfreeRegsType (result->regType) +
1003 sym->nRegs) >= result->nRegs)
1007 for (i = 0; i < result->nRegs; i++)
1009 result->regs[i] = sym->regs[i];
1011 result->regs[i] = getRegGpr (ic, ebp, result);
1013 _G.regAssigned = bitVectSetBit (_G.regAssigned, result->key);
1014 _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, result->key);
1018 /* free the remaining */
1019 for (; i < sym->nRegs; i++)
1023 if (!symHasReg (psym, sym->regs[i]))
1024 freeReg (sym->regs[i]);
1027 freeReg (sym->regs[i]);
1034 /*-----------------------------------------------------------------*/
1035 /* reassignLR - reassign this to registers */
1036 /*-----------------------------------------------------------------*/
1038 reassignLR (operand * op)
1040 symbol *sym = OP_SYMBOL (op);
1043 /* not spilt any more */
1044 sym->isspilt = sym->spillA = sym->blockSpil = sym->remainSpil = 0;
1045 bitVectUnSetBit (_G.spiltSet, sym->key);
1047 _G.regAssigned = bitVectSetBit (_G.regAssigned, sym->key);
1048 _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, sym->key);
1052 for (i = 0; i < sym->nRegs; i++)
1053 sym->regs[i]->isFree = 0;
1056 /*-----------------------------------------------------------------*/
1057 /* willCauseSpill - determines if allocating will cause a spill */
1058 /*-----------------------------------------------------------------*/
1060 willCauseSpill (int nr, int rt)
1062 /* first check if there are any avlb registers
1063 of te type required */
1066 /* special case for pointer type
1067 if pointer type not avlb then
1068 check for type gpr */
1069 if (nFreeRegs (rt) >= nr)
1071 if (nFreeRegs (REG_GPR) >= nr)
1076 if (ds390_ptrRegReq)
1078 if (nFreeRegs (rt) >= nr)
1083 if (nFreeRegs (REG_PTR) +
1084 nFreeRegs (REG_GPR) >= nr)
1089 /* it will cause a spil */
1093 /*-----------------------------------------------------------------*/
1094 /* positionRegs - the allocator can allocate same registers to res- */
1095 /* ult and operand, if this happens make sure they are in the same */
1096 /* position as the operand otherwise chaos results */
1097 /*-----------------------------------------------------------------*/
1099 positionRegs (symbol * result, symbol * opsym)
1101 int count = min (result->nRegs, opsym->nRegs);
1102 int i, j = 0, shared = 0;
1105 /* if the result has been spilt then cannot share */
1110 /* first make sure that they actually share */
1111 for (i = 0; i < count; i++)
1113 for (j = 0; j < count; j++)
1115 if (result->regs[i] == opsym->regs[j] && i != j)
1125 regs *tmp = result->regs[i];
1126 result->regs[i] = result->regs[j];
1127 result->regs[j] = tmp;
1134 /*-----------------------------------------------------------------*/
1135 /* serialRegAssign - serially allocate registers to the variables */
1136 /*-----------------------------------------------------------------*/
1138 serialRegAssign (eBBlock ** ebbs, int count)
1142 /* for all blocks */
1143 for (i = 0; i < count; i++)
1148 if (ebbs[i]->noPath &&
1149 (ebbs[i]->entryLabel != entryLabel &&
1150 ebbs[i]->entryLabel != returnLabel))
1153 /* of all instructions do */
1154 for (ic = ebbs[i]->sch; ic; ic = ic->next)
1157 /* if this is an ipop that means some live
1158 range will have to be assigned again */
1160 reassignLR (IC_LEFT (ic));
1162 /* if result is present && is a true symbol */
1163 if (IC_RESULT (ic) && ic->op != IFX &&
1164 IS_TRUE_SYMOP (IC_RESULT (ic)))
1165 OP_SYMBOL (IC_RESULT (ic))->allocreq++;
1167 /* take away registers from live
1168 ranges that end at this instruction */
1169 deassignLRs (ic, ebbs[i]);
1171 /* some don't need registers */
1172 if (SKIP_IC2 (ic) ||
1173 ic->op == JUMPTABLE ||
1177 (IC_RESULT (ic) && POINTER_SET (ic)))
1180 /* now we need to allocate registers
1181 only for the result */
1184 symbol *sym = OP_SYMBOL (IC_RESULT (ic));
1190 /* if it does not need or is spilt
1191 or is already assigned to registers
1192 or will not live beyond this instructions */
1195 bitVectBitValue (_G.regAssigned, sym->key) ||
1196 sym->liveTo <= ic->seq)
1199 /* if some liverange has been spilt at the block level
1200 and this one live beyond this block then spil this
1202 if (_G.blockSpil && sym->liveTo > ebbs[i]->lSeq)
1207 /* if trying to allocate this will cause
1208 a spill and there is nothing to spill
1209 or this one is rematerializable then
1211 willCS = willCauseSpill (sym->nRegs, sym->regType);
1212 spillable = computeSpillable (ic);
1214 (willCS && bitVectIsZero (spillable)))
1222 /* if it has a spillocation & is used less than
1223 all other live ranges then spill this */
1225 if (sym->usl.spillLoc) {
1226 symbol *leastUsed = leastUsedLR (liveRangesWith (spillable,
1227 allLRs, ebbs[i], ic));
1228 if (leastUsed && leastUsed->used > sym->used) {
1233 /* if none of the liveRanges have a spillLocation then better
1234 to spill this one than anything else already assigned to registers */
1235 if (liveRangesWith(spillable,noSpilLoc,ebbs[i],ic)) {
1236 /* if this is local to this block then we might find a block spil */
1237 if (!(sym->liveFrom >= ebbs[i]->fSeq && sym->liveTo <= ebbs[i]->lSeq)) {
1245 /* if we need ptr regs for the right side
1247 if (POINTER_GET (ic) && IS_SYMOP (IC_LEFT (ic))
1248 && getSize (OP_SYMBOL (IC_LEFT (ic))->type)
1249 <= (unsigned) PTRSIZE)
1254 /* else we assign registers to it */
1255 _G.regAssigned = bitVectSetBit (_G.regAssigned, sym->key);
1256 _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, sym->key);
1258 for (j = 0; j < sym->nRegs; j++)
1260 if (sym->regType == REG_PTR)
1261 sym->regs[j] = getRegPtr (ic, ebbs[i], sym);
1263 sym->regs[j] = getRegGpr (ic, ebbs[i], sym);
1265 /* if the allocation falied which means
1266 this was spilt then break */
1270 /* if it shares registers with operands make sure
1271 that they are in the same position */
1272 if (IC_LEFT (ic) && IS_SYMOP (IC_LEFT (ic)) &&
1273 OP_SYMBOL (IC_LEFT (ic))->nRegs && ic->op != '=')
1274 positionRegs (OP_SYMBOL (IC_RESULT (ic)),
1275 OP_SYMBOL (IC_LEFT (ic)));
1276 /* do the same for the right operand */
1277 if (IC_RIGHT (ic) && IS_SYMOP (IC_RIGHT (ic)) &&
1278 OP_SYMBOL (IC_RIGHT (ic))->nRegs)
1279 positionRegs (OP_SYMBOL (IC_RESULT (ic)),
1280 OP_SYMBOL (IC_RIGHT (ic)));
1293 /*-----------------------------------------------------------------*/
1294 /* fillGaps - Try to fill in the Gaps left by Pass1 */
1295 /*-----------------------------------------------------------------*/
1296 static void fillGaps()
1301 if (getenv("DISABLE_FILL_GAPS")) return;
1303 /* First try to do DPTRuse once more since now we know what got into
1306 for (sym = hTabFirstItem(liveRanges,&key) ; sym ;
1307 sym = hTabNextItem(liveRanges,&key)) {
1309 if (sym->uptr && !sym->ruonly && getSize(sym->type) < 4) {
1310 if (packRegsDPTRuse(operandFromSymbol(sym))) {
1312 D (fprintf (stderr, "FILL GAPS: found more DPTR use for "
1314 sym->name, currFunc ? currFunc->name : "UNKNOWN"));
1315 /* if this was ssigned to registers then */
1316 if (bitVectBitValue(_G.totRegAssigned,sym->key)) {
1318 /* take it out of the register assigned set */
1319 bitVectUnSetBit(_G.totRegAssigned,sym->key);
1321 } else if (sym->usl.spillLoc) sym->usl.spillLoc->allocreq--;
1323 sym->isspilt = sym->spillA = 0;
1328 /* look for livernages that was spilt by the allocator */
1329 for (sym = hTabFirstItem(liveRanges,&key) ; sym ;
1330 sym = hTabNextItem(liveRanges,&key)) {
1335 if (!sym->spillA || !sym->clashes || sym->remat) continue ;
1337 /* find the liveRanges this one clashes with, that are
1338 still assigned to registers & mark the registers as used*/
1339 for ( i = 0 ; i < sym->clashes->size ; i ++) {
1343 if (bitVectBitValue(sym->clashes,i) == 0 || /* those that clash with this */
1344 bitVectBitValue(_G.totRegAssigned,i) == 0) /* and are still assigned to registers */
1347 assert (clr = hTabItemWithKey(liveRanges,i));
1349 /* mark these registers as used */
1350 for (k = 0 ; k < clr->nRegs ; k++ )
1351 useReg(clr->regs[k]);
1354 if (willCauseSpill(sym->nRegs,sym->regType)) {
1355 /* NOPE :( clear all registers & and continue */
1360 /* THERE IS HOPE !!!! */
1361 for (i=0; i < sym->nRegs ; i++ ) {
1362 if (sym->regType == REG_PTR)
1363 sym->regs[i] = getRegPtrNoSpil ();
1365 sym->regs[i] = getRegGprNoSpil ();
1368 /* for all its definitions & uses check if the registers
1369 allocated needs positioning NOTE: we can position
1370 only ONCE if more than One positioning required
1373 for (i = 0 ; i < sym->defs->size ; i++ ) {
1374 if (bitVectBitValue(sym->defs,i)) {
1376 if (!(ic = hTabItemWithKey(iCodehTab,i))) continue ;
1377 if (SKIP_IC(ic)) continue;
1378 assert(isSymbolEqual(sym,OP_SYMBOL(IC_RESULT(ic)))); /* just making sure */
1379 /* if left is assigned to registers */
1380 if (IS_SYMOP(IC_LEFT(ic)) &&
1381 bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_LEFT(ic))->key)) {
1382 pdone += positionRegs(sym,OP_SYMBOL(IC_LEFT(ic)));
1384 if (IS_SYMOP(IC_RIGHT(ic)) &&
1385 bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_RIGHT(ic))->key)) {
1386 pdone += positionRegs(sym,OP_SYMBOL(IC_RIGHT(ic)));
1388 if (pdone > 1) break;
1391 for (i = 0 ; i < sym->uses->size ; i++ ) {
1392 if (bitVectBitValue(sym->uses,i)) {
1394 if (!(ic = hTabItemWithKey(iCodehTab,i))) continue ;
1395 if (SKIP_IC(ic)) continue;
1396 if (!IS_ASSIGN_ICODE(ic)) continue ;
1398 /* if result is assigned to registers */
1399 if (IS_SYMOP(IC_RESULT(ic)) &&
1400 bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_RESULT(ic))->key)) {
1401 pdone += positionRegs(sym,OP_SYMBOL(IC_RESULT(ic)));
1403 if (pdone > 1) break;
1406 /* had to position more than once GIVE UP */
1408 /* UNDO all the changes we made to try this */
1410 for (i=0; i < sym->nRegs ; i++ ) {
1411 sym->regs[i] = NULL;
1414 D (fprintf (stderr, "Fill Gap gave up due to positioning for "
1415 "%s in function %s\n",
1416 sym->name, currFunc ? currFunc->name : "UNKNOWN"));
1419 D (fprintf (stderr, "FILLED GAP for %s in function %s\n",
1420 sym->name, currFunc ? currFunc->name : "UNKNOWN"));
1421 _G.totRegAssigned = bitVectSetBit(_G.totRegAssigned,sym->key);
1422 sym->isspilt = sym->spillA = 0 ;
1423 sym->usl.spillLoc->allocreq--;
1428 /*-----------------------------------------------------------------*/
1429 /* rUmaskForOp :- returns register mask for an operand */
1430 /*-----------------------------------------------------------------*/
1432 ds390_rUmaskForOp (operand * op)
1438 /* only temporaries are assigned registers */
1442 sym = OP_SYMBOL (op);
1444 /* if spilt or no registers assigned to it
1446 if (sym->isspilt || !sym->nRegs)
1449 rumask = newBitVect (ds390_nRegs);
1451 for (j = 0; j < sym->nRegs; j++)
1453 rumask = bitVectSetBit (rumask,
1454 sym->regs[j]->rIdx);
1460 /*-----------------------------------------------------------------*/
1461 /* regsUsedIniCode :- returns bit vector of registers used in iCode */
1462 /*-----------------------------------------------------------------*/
1464 regsUsedIniCode (iCode * ic)
1466 bitVect *rmask = newBitVect (ds390_nRegs);
1468 /* do the special cases first */
1471 rmask = bitVectUnion (rmask,
1472 ds390_rUmaskForOp (IC_COND (ic)));
1476 /* for the jumptable */
1477 if (ic->op == JUMPTABLE)
1479 rmask = bitVectUnion (rmask,
1480 ds390_rUmaskForOp (IC_JTCOND (ic)));
1485 /* of all other cases */
1487 rmask = bitVectUnion (rmask,
1488 ds390_rUmaskForOp (IC_LEFT (ic)));
1492 rmask = bitVectUnion (rmask,
1493 ds390_rUmaskForOp (IC_RIGHT (ic)));
1496 rmask = bitVectUnion (rmask,
1497 ds390_rUmaskForOp (IC_RESULT (ic)));
1503 /*-----------------------------------------------------------------*/
1504 /* createRegMask - for each instruction will determine the regsUsed */
1505 /*-----------------------------------------------------------------*/
1507 createRegMask (eBBlock ** ebbs, int count)
1511 /* for all blocks */
1512 for (i = 0; i < count; i++)
1516 if (ebbs[i]->noPath &&
1517 (ebbs[i]->entryLabel != entryLabel &&
1518 ebbs[i]->entryLabel != returnLabel))
1521 /* for all instructions */
1522 for (ic = ebbs[i]->sch; ic; ic = ic->next)
1527 if (SKIP_IC2 (ic) || !ic->rlive)
1530 /* first mark the registers used in this
1532 ic->rUsed = regsUsedIniCode (ic);
1533 _G.funcrUsed = bitVectUnion (_G.funcrUsed, ic->rUsed);
1535 /* now create the register mask for those
1536 registers that are in use : this is a
1537 super set of ic->rUsed */
1538 ic->rMask = newBitVect (ds390_nRegs + 1);
1540 /* for all live Ranges alive at this point */
1541 for (j = 1; j < ic->rlive->size; j++)
1546 /* if not alive then continue */
1547 if (!bitVectBitValue (ic->rlive, j))
1550 /* find the live range we are interested in */
1551 if (!(sym = hTabItemWithKey (liveRanges, j)))
1553 werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
1554 "createRegMask cannot find live range");
1558 /* special case for ruonly */
1559 if (sym->ruonly && sym->liveFrom != sym->liveTo) {
1560 int size = getSize(sym->type);
1562 for (k = 0 ; k < size; k++ )
1563 ic->rMask = bitVectSetBit (ic->rMask, j++);
1566 /* if no register assigned to it */
1567 if (!sym->nRegs || sym->isspilt)
1570 /* for all the registers allocated to it */
1571 for (k = 0; k < sym->nRegs; k++)
1574 bitVectSetBit (ic->rMask, sym->regs[k]->rIdx);
1580 /*-----------------------------------------------------------------*/
1581 /* rematStr - returns the rematerialized string for a remat var */
1582 /*-----------------------------------------------------------------*/
1584 rematStr (symbol * sym)
1587 iCode *ic = sym->rematiCode;
1592 /* if plus or minus print the right hand side */
1593 if (ic->op == '+' || ic->op == '-')
1595 sprintf (s, "0x%04x %c ", (int) operandLitValue (IC_RIGHT (ic)),
1598 ic = OP_SYMBOL (IC_LEFT (ic))->rematiCode;
1601 /* cast then continue */
1602 if (IS_CAST_ICODE(ic)) {
1603 ic = OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
1606 /* we reached the end */
1607 sprintf (s, "%s", OP_SYMBOL (IC_LEFT (ic))->rname);
1614 /*-----------------------------------------------------------------*/
1615 /* regTypeNum - computes the type & number of registers required */
1616 /*-----------------------------------------------------------------*/
1624 /* for each live range do */
1625 for (sym = hTabFirstItem (liveRanges, &k); sym;
1626 sym = hTabNextItem (liveRanges, &k))
1629 /* if used zero times then no registers needed */
1630 if ((sym->liveTo - sym->liveFrom) == 0)
1634 /* if the live range is a temporary */
1638 /* if the type is marked as a conditional */
1639 if (sym->regType == REG_CND)
1642 /* if used in return only then we don't
1644 if (sym->ruonly || sym->accuse)
1646 if (IS_AGGREGATE (sym->type) || sym->isptr)
1647 sym->type = aggrToPtr (sym->type, FALSE);
1651 /* if the symbol has only one definition &
1652 that definition is a get_pointer and the
1653 pointer we are getting is rematerializable and
1656 if (bitVectnBitsOn (sym->defs) == 1 &&
1657 (ic = hTabItemWithKey (iCodehTab,
1658 bitVectFirstBit (sym->defs))) &&
1661 !IS_BITVAR (sym->etype))
1665 /* if remat in data space */
1666 if (OP_SYMBOL (IC_LEFT (ic))->remat &&
1667 !IS_CAST_ICODE(OP_SYMBOL (IC_LEFT (ic))->rematiCode) &&
1668 DCL_TYPE (aggrToPtr (sym->type, FALSE)) == POINTER)
1671 /* create a psuedo symbol & force a spil */
1672 symbol *psym = newSymbol (rematStr (OP_SYMBOL (IC_LEFT (ic))), 1);
1673 psym->type = sym->type;
1674 psym->etype = sym->etype;
1675 strcpy (psym->rname, psym->name);
1677 sym->usl.spillLoc = psym;
1681 /* if in data space or idata space then try to
1682 allocate pointer register */
1686 /* if not then we require registers */
1687 sym->nRegs = ((IS_AGGREGATE (sym->type) || sym->isptr) ?
1688 getSize (sym->type = aggrToPtr (sym->type, FALSE)) :
1689 getSize (sym->type));
1693 fprintf (stderr, "allocated more than 4 or 0 registers for type ");
1694 printTypeChain (sym->type, stderr);
1695 fprintf (stderr, "\n");
1698 /* determine the type of register required */
1699 if (sym->nRegs == 1 &&
1700 IS_PTR (sym->type) &&
1702 sym->regType = REG_PTR;
1704 sym->regType = REG_GPR;
1708 /* for the first run we don't provide */
1709 /* registers for true symbols we will */
1710 /* see how things go */
1716 /*-----------------------------------------------------------------*/
1717 /* freeAllRegs - mark all registers as free */
1718 /*-----------------------------------------------------------------*/
1724 for (i = 0; i < ds390_nRegs; i++)
1725 regs390[i].isFree = 1;
1728 /*-----------------------------------------------------------------*/
1729 /* deallocStackSpil - this will set the stack pointer back */
1730 /*-----------------------------------------------------------------*/
1732 DEFSETFUNC (deallocStackSpil)
1740 /*-----------------------------------------------------------------*/
1741 /* farSpacePackable - returns the packable icode for far variables */
1742 /*-----------------------------------------------------------------*/
1744 farSpacePackable (iCode * ic)
1748 /* go thru till we find a definition for the
1749 symbol on the right */
1750 for (dic = ic->prev; dic; dic = dic->prev)
1753 /* if the definition is a call then no */
1754 if ((dic->op == CALL || dic->op == PCALL) &&
1755 IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
1760 /* if shift by unknown amount then not */
1761 if ((dic->op == LEFT_OP || dic->op == RIGHT_OP) &&
1762 IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
1765 /* if pointer get and size > 1 */
1766 if (POINTER_GET (dic) &&
1767 getSize (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)) > 1)
1770 if (POINTER_SET (dic) &&
1771 getSize (aggrToPtr (operandType (IC_RESULT (dic)), FALSE)) > 1)
1774 /* if any three is a true symbol in far space */
1775 if (IC_RESULT (dic) &&
1776 IS_TRUE_SYMOP (IC_RESULT (dic)) &&
1777 isOperandInFarSpace (IC_RESULT (dic)))
1780 if (IC_RIGHT (dic) &&
1781 IS_TRUE_SYMOP (IC_RIGHT (dic)) &&
1782 isOperandInFarSpace (IC_RIGHT (dic)) &&
1783 !isOperandEqual (IC_RIGHT (dic), IC_RESULT (ic)))
1786 if (IC_LEFT (dic) &&
1787 IS_TRUE_SYMOP (IC_LEFT (dic)) &&
1788 isOperandInFarSpace (IC_LEFT (dic)) &&
1789 !isOperandEqual (IC_LEFT (dic), IC_RESULT (ic)))
1792 if (isOperandEqual (IC_RIGHT (ic), IC_RESULT (dic)))
1794 if ((dic->op == LEFT_OP ||
1795 dic->op == RIGHT_OP ||
1797 IS_OP_LITERAL (IC_RIGHT (dic)))
1807 /*-----------------------------------------------------------------*/
1808 /* packRegsForAssign - register reduction for assignment */
1809 /*-----------------------------------------------------------------*/
1811 packRegsForAssign (iCode * ic, eBBlock * ebp)
1815 if (!IS_ITEMP (IC_RIGHT (ic)) ||
1816 OP_SYMBOL (IC_RIGHT (ic))->isind ||
1817 OP_LIVETO (IC_RIGHT (ic)) > ic->seq)
1822 /* if the true symbol is defined in far space or on stack
1823 then we should not since this will increase register pressure */
1825 if (isOperandInFarSpace (IC_RESULT (ic)))
1827 if ((dic = farSpacePackable (ic)))
1833 if (isOperandInFarSpace(IC_RESULT(ic)) && !farSpacePackable(ic)) {
1838 /* find the definition of iTempNN scanning backwards if we find a
1839 a use of the true symbol in before we find the definition then
1841 for (dic = ic->prev; dic; dic = dic->prev)
1843 /* if there is a function call then don't pack it */
1844 if ((dic->op == CALL || dic->op == PCALL))
1853 if (IS_TRUE_SYMOP (IC_RESULT (dic)) &&
1854 IS_OP_VOLATILE (IC_RESULT (dic)))
1860 if (IS_SYMOP (IC_RESULT (dic)) &&
1861 IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
1863 if (POINTER_SET (dic))
1869 if (IS_SYMOP (IC_RIGHT (dic)) &&
1870 (IC_RIGHT (dic)->key == IC_RESULT (ic)->key ||
1871 IC_RIGHT (dic)->key == IC_RIGHT (ic)->key))
1877 if (IS_SYMOP (IC_LEFT (dic)) &&
1878 (IC_LEFT (dic)->key == IC_RESULT (ic)->key ||
1879 IC_LEFT (dic)->key == IC_RIGHT (ic)->key))
1885 if (POINTER_SET (dic) &&
1886 IC_RESULT (dic)->key == IC_RESULT (ic)->key)
1894 return 0; /* did not find */
1896 /* if the result is on stack or iaccess then it must be
1897 the same atleast one of the operands */
1898 if (OP_SYMBOL (IC_RESULT (ic))->onStack ||
1899 OP_SYMBOL (IC_RESULT (ic))->iaccess)
1902 /* the operation has only one symbol
1903 operator then we can pack */
1904 if ((IC_LEFT (dic) && !IS_SYMOP (IC_LEFT (dic))) ||
1905 (IC_RIGHT (dic) && !IS_SYMOP (IC_RIGHT (dic))))
1908 if (!((IC_LEFT (dic) &&
1909 IC_RESULT (ic)->key == IC_LEFT (dic)->key) ||
1911 IC_RESULT (ic)->key == IC_RIGHT (dic)->key)))
1915 /* found the definition */
1916 /* replace the result with the result of */
1917 /* this assignment and remove this assignment */
1918 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
1919 IC_RESULT (dic) = IC_RESULT (ic);
1921 if (IS_ITEMP (IC_RESULT (dic)) && OP_SYMBOL (IC_RESULT (dic))->liveFrom > dic->seq)
1923 OP_SYMBOL (IC_RESULT (dic))->liveFrom = dic->seq;
1925 /* delete from liverange table also
1926 delete from all the points inbetween and the new
1928 for (sic = dic; sic != ic; sic = sic->next)
1930 bitVectUnSetBit (sic->rlive, IC_RESULT (ic)->key);
1931 if (IS_ITEMP (IC_RESULT (dic)))
1932 bitVectSetBit (sic->rlive, IC_RESULT (dic)->key);
1935 remiCodeFromeBBlock (ebp, ic);
1936 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
1937 hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
1938 OP_DEFS (IC_RESULT (dic)) = bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
1943 /*-----------------------------------------------------------------*/
1944 /* findAssignToSym : scanning backwards looks for first assig found */
1945 /*-----------------------------------------------------------------*/
1947 findAssignToSym (operand * op, iCode * ic)
1951 for (dic = ic->prev; dic; dic = dic->prev)
1954 /* if definition by assignment */
1955 if (dic->op == '=' &&
1956 !POINTER_SET (dic) &&
1957 IC_RESULT (dic)->key == op->key
1958 /* && IS_TRUE_SYMOP(IC_RIGHT(dic)) */
1962 /* we are interested only if defined in far space */
1963 /* or in stack space in case of + & - */
1965 /* if assigned to a non-symbol then return
1967 if (!IS_SYMOP (IC_RIGHT (dic)))
1970 /* if the symbol is in far space then
1972 if (isOperandInFarSpace (IC_RIGHT (dic)))
1975 /* for + & - operations make sure that
1976 if it is on the stack it is the same
1977 as one of the three operands */
1978 if ((ic->op == '+' || ic->op == '-') &&
1979 OP_SYMBOL (IC_RIGHT (dic))->onStack)
1982 if (IC_RESULT (ic)->key != IC_RIGHT (dic)->key &&
1983 IC_LEFT (ic)->key != IC_RIGHT (dic)->key &&
1984 IC_RIGHT (ic)->key != IC_RIGHT (dic)->key)
1992 /* if we find an usage then we cannot delete it */
1993 if (IC_LEFT (dic) && IC_LEFT (dic)->key == op->key)
1996 if (IC_RIGHT (dic) && IC_RIGHT (dic)->key == op->key)
1999 if (POINTER_SET (dic) && IC_RESULT (dic)->key == op->key)
2003 /* now make sure that the right side of dic
2004 is not defined between ic & dic */
2007 iCode *sic = dic->next;
2009 for (; sic != ic; sic = sic->next)
2010 if (IC_RESULT (sic) &&
2011 IC_RESULT (sic)->key == IC_RIGHT (dic)->key)
2020 /*-----------------------------------------------------------------*/
2021 /* packRegsForSupport :- reduce some registers for support calls */
2022 /*-----------------------------------------------------------------*/
2024 packRegsForSupport (iCode * ic, eBBlock * ebp)
2028 /* for the left & right operand :- look to see if the
2029 left was assigned a true symbol in far space in that
2030 case replace them */
2031 if (IS_ITEMP (IC_LEFT (ic)) &&
2032 OP_SYMBOL (IC_LEFT (ic))->liveTo <= ic->seq)
2034 iCode *dic = findAssignToSym (IC_LEFT (ic), ic);
2040 /* found it we need to remove it from the
2042 for (sic = dic; sic != ic; sic = sic->next)
2043 bitVectUnSetBit (sic->rlive, IC_LEFT (ic)->key);
2045 IC_LEFT (ic)->operand.symOperand =
2046 IC_RIGHT (dic)->operand.symOperand;
2047 IC_LEFT (ic)->key = IC_RIGHT (dic)->operand.symOperand->key;
2048 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2049 remiCodeFromeBBlock (ebp, dic);
2050 hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2054 /* do the same for the right operand */
2057 IS_ITEMP (IC_RIGHT (ic)) &&
2058 OP_SYMBOL (IC_RIGHT (ic))->liveTo <= ic->seq)
2060 iCode *dic = findAssignToSym (IC_RIGHT (ic), ic);
2066 /* if this is a subtraction & the result
2067 is a true symbol in far space then don't pack */
2068 if (ic->op == '-' && IS_TRUE_SYMOP (IC_RESULT (dic)))
2070 sym_link *etype = getSpec (operandType (IC_RESULT (dic)));
2071 if (IN_FARSPACE (SPEC_OCLS (etype)))
2074 /* found it we need to remove it from the
2076 for (sic = dic; sic != ic; sic = sic->next)
2077 bitVectUnSetBit (sic->rlive, IC_RIGHT (ic)->key);
2079 IC_RIGHT (ic)->operand.symOperand =
2080 IC_RIGHT (dic)->operand.symOperand;
2081 IC_RIGHT (ic)->key = IC_RIGHT (dic)->operand.symOperand->key;
2083 remiCodeFromeBBlock (ebp, dic);
2084 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2085 hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2092 #define IS_OP_RUONLY(x) (x && IS_SYMOP(x) && OP_SYMBOL(x)->ruonly)
2095 /*-----------------------------------------------------------------*/
2096 /* packRegsDPTRuse : - will reduce some registers for single Use */
2097 /*-----------------------------------------------------------------*/
2099 packRegsDPTRuse (operand * op)
2101 /* go thru entire liveRange of this variable & check for
2102 other possible usage of DPTR , if we don't find it the
2103 assign this to DPTR (ruonly)
2108 sym_link *type, *etype;
2110 if (!IS_SYMOP(op) || !IS_ITEMP(op)) return NULL;
2111 if (OP_SYMBOL(op)->remat || OP_SYMBOL(op)->ruonly) return NULL;
2113 /* first check if any overlapping liverange has already been
2115 if (OP_SYMBOL(op)->clashes) {
2116 for (i = 0 ; i < OP_SYMBOL(op)->clashes->size ; i++ ) {
2117 if (bitVectBitValue(OP_SYMBOL(op)->clashes,i)) {
2118 sym = hTabItemWithKey(liveRanges,i);
2119 if (sym->ruonly) return NULL ;
2124 /* no then go thru this guys live range */
2125 dic = ic = hTabFirstItemWK(iCodeSeqhTab,OP_SYMBOL(op)->liveFrom);
2126 for (; ic && ic->seq <= OP_SYMBOL(op)->liveTo;
2127 ic = hTabNextItem(iCodeSeqhTab,&key)) {
2129 if (SKIP_IC3(ic)) continue;
2131 /* if PCALL cannot be sure give up */
2132 if (ic->op == PCALL) return NULL;
2134 /* if CALL then make sure it is VOID || return value not used
2135 or the return value is assigned to this one */
2136 if (ic->op == CALL) {
2137 if (OP_SYMBOL(IC_RESULT(ic))->liveTo ==
2138 OP_SYMBOL(IC_RESULT(ic))->liveFrom) continue ;
2139 etype = getSpec(type = operandType(IC_RESULT(ic)));
2141 if (getSize(type) == 0 || isOperandEqual(op,IC_RESULT(ic)))
2143 if (getSize(type) == 0)
2148 /* special case of add with a [remat] */
2149 if (ic->op == '+' &&
2150 OP_SYMBOL(IC_LEFT(ic))->remat &&
2151 (isOperandInFarSpace(IC_RIGHT(ic)) &&
2152 !isOperandInReg(IC_RIGHT(ic)))) return NULL ;
2156 if (POINTER_GET(ic) && !isOperandEqual(IC_LEFT(ic),op) &&
2157 getSize(operandType(IC_LEFT(ic))) > 1 ) return NULL ;
2160 if (POINTER_SET(ic) && !isOperandEqual(IC_RESULT(ic),op) &&
2161 getSize(operandType(IC_RESULT(ic))) > 1 ) return NULL;
2163 /* conditionals can destroy 'b' - make sure B wont be used in this one*/
2164 if ((IS_CONDITIONAL(ic) || ic->op == '*' || ic->op == '/' ) &&
2165 getSize(operandType(op)) > 3) return NULL;
2168 if (IC_RESULT(ic) && IS_SYMOP(IC_RESULT(ic)) &&
2169 !isOperandEqual(IC_RESULT(ic),op) &&
2170 ((isOperandInFarSpace(IC_RESULT(ic)) && !isOperandInReg(IC_RESULT(ic))) ||
2171 OP_SYMBOL(IC_RESULT(ic))->ruonly ||
2172 OP_SYMBOL(IC_RESULT(ic))->onStack)) return NULL;
2174 if (IC_RIGHT(ic) && IS_SYMOP(IC_RIGHT(ic)) &&
2175 !isOperandEqual(IC_RIGHT(ic),op) &&
2176 (OP_SYMBOL(IC_RIGHT(ic))->liveTo > ic->seq ||
2177 IS_TRUE_SYMOP(IC_RIGHT(ic)) ||
2178 OP_SYMBOL(IC_RIGHT(ic))->ruonly) &&
2179 ((isOperandInFarSpace(IC_RIGHT(ic)) && !isOperandInReg(IC_RIGHT(ic)))||
2180 OP_SYMBOL(IC_RIGHT(ic))->onStack)) return NULL;
2182 if (IC_LEFT(ic) && IS_SYMOP(IC_LEFT(ic)) &&
2183 !isOperandEqual(IC_LEFT(ic),op) &&
2184 (OP_SYMBOL(IC_LEFT(ic))->liveTo > ic->seq ||
2185 IS_TRUE_SYMOP(IC_LEFT(ic)) ||
2186 OP_SYMBOL(IC_LEFT(ic))->ruonly) &&
2187 ((isOperandInFarSpace(IC_LEFT(ic)) && !isOperandInReg(IC_LEFT(ic)))||
2188 OP_SYMBOL(IC_LEFT(ic))->onStack)) return NULL;
2190 if (IC_LEFT(ic) && IC_RIGHT(ic) &&
2191 IS_ITEMP(IC_LEFT(ic)) && IS_ITEMP(IC_RIGHT(ic)) &&
2192 (isOperandInFarSpace(IC_LEFT(ic)) && !isOperandInReg(IC_LEFT(ic))) &&
2193 (isOperandInFarSpace(IC_RIGHT(ic)) && !isOperandInReg(IC_RIGHT(ic))))
2196 OP_SYMBOL(op)->ruonly = 1;
2200 /*-----------------------------------------------------------------*/
2201 /* isBitwiseOptimizable - requirements of JEAN LOUIS VERN */
2202 /*-----------------------------------------------------------------*/
2204 isBitwiseOptimizable (iCode * ic)
2206 sym_link *ltype = getSpec (operandType (IC_LEFT (ic)));
2207 sym_link *rtype = getSpec (operandType (IC_RIGHT (ic)));
2209 /* bitwise operations are considered optimizable
2210 under the following conditions (Jean-Louis VERN)
2222 if ( IS_LITERAL (rtype) ||
2223 (IS_BITVAR (ltype) && IN_BITSPACE (SPEC_OCLS (ltype))))
2229 /*-----------------------------------------------------------------*/
2230 /* packRegsForAccUse - pack registers for acc use */
2231 /*-----------------------------------------------------------------*/
2233 packRegsForAccUse (iCode * ic)
2237 /* if this is an aggregate, e.g. a one byte char array */
2238 if (IS_AGGREGATE(operandType(IC_RESULT(ic)))) {
2242 /* if + or - then it has to be one byte result */
2243 if ((ic->op == '+' || ic->op == '-')
2244 && getSize (operandType (IC_RESULT (ic))) > 1)
2247 /* if shift operation make sure right side is not a literal */
2248 if (ic->op == RIGHT_OP &&
2249 (isOperandLiteral (IC_RIGHT (ic)) ||
2250 getSize (operandType (IC_RESULT (ic))) > 1))
2253 if (ic->op == LEFT_OP &&
2254 (isOperandLiteral (IC_RIGHT (ic)) ||
2255 getSize (operandType (IC_RESULT (ic))) > 1))
2258 if (IS_BITWISE_OP (ic) &&
2259 getSize (operandType (IC_RESULT (ic))) > 1)
2263 /* has only one definition */
2264 if (bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) > 1)
2267 /* has only one use */
2268 if (bitVectnBitsOn (OP_USES (IC_RESULT (ic))) > 1)
2271 /* and the usage immediately follows this iCode */
2272 if (!(uic = hTabItemWithKey (iCodehTab,
2273 bitVectFirstBit (OP_USES (IC_RESULT (ic))))))
2276 if (ic->next != uic)
2279 /* if it is a conditional branch then we definitely can */
2283 if (uic->op == JUMPTABLE)
2286 /* if the usage is not is an assignment
2287 or an arithmetic / bitwise / shift operation then not */
2288 if (POINTER_SET (uic) &&
2289 getSize (aggrToPtr (operandType (IC_RESULT (uic)), FALSE)) > 1)
2292 if (uic->op != '=' &&
2293 !IS_ARITHMETIC_OP (uic) &&
2294 !IS_BITWISE_OP (uic) &&
2295 uic->op != LEFT_OP &&
2296 uic->op != RIGHT_OP)
2299 /* if used in ^ operation then make sure right is not a
2301 if (uic->op == '^' && isOperandLiteral (IC_RIGHT (uic)))
2304 /* if shift operation make sure right side is not a literal */
2305 if (uic->op == RIGHT_OP &&
2306 (isOperandLiteral (IC_RIGHT (uic)) ||
2307 getSize (operandType (IC_RESULT (uic))) > 1))
2310 if (uic->op == LEFT_OP &&
2311 (isOperandLiteral (IC_RIGHT (uic)) ||
2312 getSize (operandType (IC_RESULT (uic))) > 1))
2315 /* make sure that the result of this icode is not on the
2316 stack, since acc is used to compute stack offset */
2318 if (IS_TRUE_SYMOP (IC_RESULT (uic)) &&
2319 OP_SYMBOL (IC_RESULT (uic))->onStack)
2322 if (isOperandOnStack(IC_RESULT(uic)))
2326 /* if either one of them in far space then we cannot */
2327 if ((IS_TRUE_SYMOP (IC_LEFT (uic)) &&
2328 isOperandInFarSpace (IC_LEFT (uic))) ||
2329 (IS_TRUE_SYMOP (IC_RIGHT (uic)) &&
2330 isOperandInFarSpace (IC_RIGHT (uic))))
2333 /* if the usage has only one operand then we can */
2334 if (IC_LEFT (uic) == NULL ||
2335 IC_RIGHT (uic) == NULL)
2338 /* make sure this is on the left side if not
2339 a '+' since '+' is commutative */
2340 if (ic->op != '+' &&
2341 IC_LEFT (uic)->key != IC_RESULT (ic)->key)
2345 // this is too dangerous and need further restrictions
2348 /* if one of them is a literal then we can */
2349 if ((IC_LEFT (uic) && IS_OP_LITERAL (IC_LEFT (uic))) ||
2350 (IC_RIGHT (uic) && IS_OP_LITERAL (IC_RIGHT (uic))))
2352 OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
2357 /* if the other one is not on stack then we can */
2358 if (IC_LEFT (uic)->key == IC_RESULT (ic)->key &&
2359 (IS_ITEMP (IC_RIGHT (uic)) ||
2360 (IS_TRUE_SYMOP (IC_RIGHT (uic)) &&
2361 !OP_SYMBOL (IC_RIGHT (uic))->onStack)))
2364 if (IC_RIGHT (uic)->key == IC_RESULT (ic)->key &&
2365 (IS_ITEMP (IC_LEFT (uic)) ||
2366 (IS_TRUE_SYMOP (IC_LEFT (uic)) &&
2367 !OP_SYMBOL (IC_LEFT (uic))->onStack)))
2373 OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
2378 /*-----------------------------------------------------------------*/
2379 /* packForPush - hueristics to reduce iCode for pushing */
2380 /*-----------------------------------------------------------------*/
2382 packForPush (iCode * ic, eBBlock * ebp)
2387 if (ic->op != IPUSH || !IS_ITEMP (IC_LEFT (ic)))
2390 /* must have only definition & one usage */
2391 if (bitVectnBitsOn (OP_DEFS (IC_LEFT (ic))) != 1 ||
2392 bitVectnBitsOn (OP_USES (IC_LEFT (ic))) != 1)
2395 /* find the definition */
2396 if (!(dic = hTabItemWithKey (iCodehTab,
2397 bitVectFirstBit (OP_DEFS (IC_LEFT (ic))))))
2400 if (dic->op != '=' || POINTER_SET (dic))
2403 /* make sure the right side does not have any definitions
2405 dbv = OP_DEFS(IC_RIGHT(dic));
2406 for (lic = ic; lic && lic != dic ; lic = lic->prev) {
2407 if (bitVectBitValue(dbv,lic->key)) return ;
2409 /* make sure they have the same type */
2411 sym_link *itype=operandType(IC_LEFT(ic));
2412 sym_link *ditype=operandType(IC_RIGHT(dic));
2414 if (SPEC_USIGN(itype)!=SPEC_USIGN(ditype) ||
2415 SPEC_LONG(itype)!=SPEC_LONG(ditype))
2418 /* extend the live range of replaced operand if needed */
2419 if (OP_SYMBOL(IC_RIGHT(dic))->liveTo < ic->seq) {
2420 OP_SYMBOL(IC_RIGHT(dic))->liveTo = ic->seq;
2422 /* we now we know that it has one & only one def & use
2423 and the that the definition is an assignment */
2424 IC_LEFT (ic) = IC_RIGHT (dic);
2426 remiCodeFromeBBlock (ebp, dic);
2427 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2428 hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2431 /*-----------------------------------------------------------------*/
2432 /* packRegisters - does some transformations to reduce register */
2434 /*-----------------------------------------------------------------*/
2436 packRegisters (eBBlock * ebp)
2446 /* look for assignments of the form */
2447 /* iTempNN = TRueSym (someoperation) SomeOperand */
2449 /* TrueSym := iTempNN:1 */
2450 for (ic = ebp->sch; ic; ic = ic->next)
2454 /* find assignment of the form TrueSym := iTempNN:1 */
2455 if (ic->op == '=' && !POINTER_SET (ic))
2456 change += packRegsForAssign (ic, ebp);
2463 for (ic = ebp->sch; ic; ic = ic->next)
2466 /* if this is an itemp & result of a address of a true sym
2467 then mark this as rematerialisable */
2468 if (ic->op == ADDRESS_OF &&
2469 IS_ITEMP (IC_RESULT (ic)) &&
2470 IS_TRUE_SYMOP (IC_LEFT (ic)) &&
2471 bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
2472 !OP_SYMBOL (IC_LEFT (ic))->onStack)
2475 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2476 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2477 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2481 /* if straight assignment then carry remat flag if
2482 this is the only definition */
2483 if (ic->op == '=' &&
2484 !POINTER_SET (ic) &&
2485 IS_SYMOP (IC_RIGHT (ic)) &&
2486 OP_SYMBOL (IC_RIGHT (ic))->remat &&
2487 !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode) &&
2488 bitVectnBitsOn (OP_SYMBOL (IC_RESULT (ic))->defs) <= 1)
2491 OP_SYMBOL (IC_RESULT (ic))->remat =
2492 OP_SYMBOL (IC_RIGHT (ic))->remat;
2493 OP_SYMBOL (IC_RESULT (ic))->rematiCode =
2494 OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
2497 /* if cast to a generic pointer & the pointer being
2498 cast is remat, then we can remat this cast as well */
2499 if (ic->op == CAST &&
2500 IS_SYMOP(IC_RIGHT(ic)) &&
2501 OP_SYMBOL(IC_RIGHT(ic))->remat ) {
2502 sym_link *to_type = operandType(IC_LEFT(ic));
2503 sym_link *from_type = operandType(IC_RIGHT(ic));
2504 if (IS_GENPTR(to_type) && IS_PTR(from_type)) {
2505 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2506 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2507 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2511 /* if this is a +/- operation with a rematerizable
2512 then mark this as rematerializable as well */
2513 if ((ic->op == '+' || ic->op == '-') &&
2514 (IS_SYMOP (IC_LEFT (ic)) &&
2515 IS_ITEMP (IC_RESULT (ic)) &&
2516 OP_SYMBOL (IC_LEFT (ic))->remat &&
2517 (!IS_SYMOP (IC_RIGHT (ic)) || !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode)) &&
2518 bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
2519 IS_OP_LITERAL (IC_RIGHT (ic))))
2522 //int i = operandLitValue(IC_RIGHT(ic));
2523 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2524 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2525 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2528 /* mark the pointer usages */
2529 if (POINTER_SET (ic))
2530 OP_SYMBOL (IC_RESULT (ic))->uptr = 1;
2532 if (POINTER_GET (ic))
2533 OP_SYMBOL (IC_LEFT (ic))->uptr = 1;
2535 if (ic->op == RETURN && IS_SYMOP (IC_LEFT(ic)))
2536 OP_SYMBOL (IC_LEFT (ic))->uptr = 1;
2540 /* if we are using a symbol on the stack
2541 then we should say ds390_ptrRegReq */
2542 if (ic->op == IFX && IS_SYMOP (IC_COND (ic)))
2543 ds390_ptrRegReq += ((OP_SYMBOL (IC_COND (ic))->onStack ? !options.stack10bit : 0) +
2544 OP_SYMBOL (IC_COND (ic))->iaccess);
2545 else if (ic->op == JUMPTABLE && IS_SYMOP (IC_JTCOND (ic)))
2546 ds390_ptrRegReq += ((OP_SYMBOL (IC_JTCOND (ic))->onStack ? !options.stack10bit : 0) +
2547 OP_SYMBOL (IC_JTCOND (ic))->iaccess);
2550 if (IS_SYMOP (IC_LEFT (ic)))
2551 ds390_ptrRegReq += ((OP_SYMBOL (IC_LEFT (ic))->onStack ? !options.stack10bit : 0) +
2552 OP_SYMBOL (IC_LEFT (ic))->iaccess);
2553 if (IS_SYMOP (IC_RIGHT (ic)))
2554 ds390_ptrRegReq += ((OP_SYMBOL (IC_RIGHT (ic))->onStack ? !options.stack10bit : 0) +
2555 OP_SYMBOL (IC_RIGHT (ic))->iaccess);
2556 if (IS_SYMOP (IC_RESULT (ic)))
2557 ds390_ptrRegReq += ((OP_SYMBOL (IC_RESULT (ic))->onStack ? !options.stack10bit : 0) +
2558 OP_SYMBOL (IC_RESULT (ic))->iaccess);
2563 /* if the condition of an if instruction
2564 is defined in the previous instruction then
2565 mark the itemp as a conditional */
2566 if ((IS_CONDITIONAL (ic) ||
2567 (IS_BITWISE_OP(ic) && isBitwiseOptimizable(ic))) &&
2568 ic->next && ic->next->op == IFX &&
2569 isOperandEqual (IC_RESULT (ic), IC_COND (ic->next)) &&
2570 OP_SYMBOL (IC_RESULT (ic))->liveTo <= ic->next->seq)
2573 OP_SYMBOL (IC_RESULT (ic))->regType = REG_CND;
2577 /* if the condition of an if instruction
2578 is defined in the previous instruction and
2579 this is the only usage then
2580 mark the itemp as a conditional */
2581 if ((IS_CONDITIONAL (ic) ||
2582 (IS_BITWISE_OP(ic) && isBitwiseOptimizable (ic))) &&
2583 ic->next && ic->next->op == IFX &&
2584 bitVectnBitsOn (OP_USES(IC_RESULT(ic)))==1 &&
2585 isOperandEqual (IC_RESULT (ic), IC_COND (ic->next)) &&
2586 OP_SYMBOL (IC_RESULT (ic))->liveTo <= ic->next->seq)
2588 OP_SYMBOL (IC_RESULT (ic))->regType = REG_CND;
2594 /* reduce for support function calls */
2595 if (ic->supportRtn || ic->op == '+' || ic->op == '-')
2596 packRegsForSupport (ic, ebp);
2599 /* some cases the redundant moves can
2600 can be eliminated for return statements */
2601 if ((ic->op == RETURN || ic->op == SEND) &&
2602 !isOperandInFarSpace (IC_LEFT (ic)) &&
2605 packRegsDPTRuse (IC_LEFT (ic));
2608 if (ic->op == CALL) {
2609 sym_link *ftype = operandType(IC_LEFT(ic));
2610 if (getSize(operandType(IC_RESULT(ic))) <= 4 &&
2611 !IFFUNC_ISBUILTIN(ftype)) {
2612 packRegsDPTRuse (IC_RESULT (ic));
2616 /* if pointer set & left has a size more than
2617 one and right is not in far space */
2618 if (POINTER_SET (ic) &&
2619 !isOperandInFarSpace (IC_RIGHT (ic)) &&
2620 !OP_SYMBOL (IC_RESULT (ic))->remat &&
2621 !IS_OP_RUONLY (IC_RIGHT (ic)) &&
2622 getSize (aggrToPtr (operandType (IC_RESULT (ic)), FALSE)) > 1) {
2624 packRegsDPTRuse (IC_RESULT (ic));
2627 /* if pointer get */
2628 if (POINTER_GET (ic) &&
2629 !isOperandInFarSpace (IC_RESULT (ic)) &&
2630 !OP_SYMBOL (IC_LEFT (ic))->remat &&
2631 !IS_OP_RUONLY (IC_RESULT (ic)) &&
2632 getSize (aggrToPtr (operandType (IC_LEFT (ic)), FALSE)) > 1) {
2634 packRegsDPTRuse (IC_LEFT (ic));
2637 /* if this is cast for intergral promotion then
2638 check if only use of the definition of the
2639 operand being casted/ if yes then replace
2640 the result of that arithmetic operation with
2641 this result and get rid of the cast */
2644 sym_link *fromType = operandType (IC_RIGHT (ic));
2645 sym_link *toType = operandType (IC_LEFT (ic));
2647 if (IS_INTEGRAL (fromType) && IS_INTEGRAL (toType) &&
2648 getSize (fromType) != getSize (toType) &&
2649 SPEC_USIGN (fromType) == SPEC_USIGN (toType))
2652 iCode *dic = packRegsDPTRuse (IC_RIGHT (ic));
2655 if (IS_ARITHMETIC_OP (dic))
2657 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2658 IC_RESULT (dic) = IC_RESULT (ic);
2659 remiCodeFromeBBlock (ebp, ic);
2660 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
2661 hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
2662 OP_DEFS (IC_RESULT (dic)) = bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
2666 OP_SYMBOL (IC_RIGHT (ic))->ruonly = 0;
2672 /* if the type from and type to are the same
2673 then if this is the only use then packit */
2674 if (compareType (operandType (IC_RIGHT (ic)),
2675 operandType (IC_LEFT (ic))) == 1)
2677 iCode *dic = packRegsDPTRuse (IC_RIGHT (ic));
2680 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
2681 IC_RESULT (dic) = IC_RESULT (ic);
2682 remiCodeFromeBBlock (ebp, ic);
2683 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
2684 hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
2685 OP_DEFS (IC_RESULT (dic)) = bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
2693 iTempNN := (some variable in farspace) V1
2698 if (ic->op == IPUSH)
2700 packForPush (ic, ebp);
2704 /* pack registers for accumulator use, when the
2705 result of an arithmetic or bit wise operation
2706 has only one use, that use is immediately following
2707 the defintion and the using iCode has only one
2708 operand or has two operands but one is literal &
2709 the result of that operation is not on stack then
2710 we can leave the result of this operation in acc:b
2712 if ((IS_ARITHMETIC_OP (ic)
2713 || IS_CONDITIONAL(ic)
2714 || IS_BITWISE_OP (ic)
2715 || ic->op == LEFT_OP || ic->op == RIGHT_OP || ic->op == CALL
2716 || (ic->op == ADDRESS_OF && isOperandOnStack (IC_LEFT (ic)))
2718 IS_ITEMP (IC_RESULT (ic)) &&
2719 getSize (operandType (IC_RESULT (ic))) <= 2)
2721 packRegsForAccUse (ic);
2726 /*-----------------------------------------------------------------*/
2727 /* assignRegisters - assigns registers to each live range as need */
2728 /*-----------------------------------------------------------------*/
2730 ds390_assignRegisters (eBBlock ** ebbs, int count)
2735 setToNull ((void *) &_G.funcrUsed);
2736 setToNull ((void *) &_G.regAssigned);
2737 setToNull ((void *) &_G.totRegAssigned);
2738 setToNull ((void *) &_G.funcrUsed);
2739 ds390_ptrRegReq = _G.stackExtend = _G.dataExtend = 0;
2741 if (options.model != MODEL_FLAT24) options.stack10bit = 0;
2742 /* change assignments this will remove some
2743 live ranges reducing some register pressure */
2744 for (i = 0; i < count; i++)
2745 packRegisters (ebbs[i]);
2747 if (options.dump_pack)
2748 dumpEbbsToFileExt (DUMP_PACK, ebbs, count);
2750 /* first determine for each live range the number of
2751 registers & the type of registers required for each */
2754 /* and serially allocate registers */
2755 serialRegAssign (ebbs, count);
2762 /* if stack was extended then tell the user */
2765 /* werror(W_TOOMANY_SPILS,"stack", */
2766 /* _G.stackExtend,currFunc->name,""); */
2772 /* werror(W_TOOMANY_SPILS,"data space", */
2773 /* _G.dataExtend,currFunc->name,""); */
2777 /* after that create the register mask
2778 for each of the instruction */
2779 createRegMask (ebbs, count);
2781 /* redo that offsets for stacked automatic variables */
2782 redoStackOffsets ();
2784 if (options.dump_rassgn) {
2785 dumpEbbsToFileExt (DUMP_RASSGN, ebbs, count);
2786 dumpLiveRanges (DUMP_LRANGE, liveRanges);
2789 /* do the overlaysegment stuff SDCCmem.c */
2790 doOverlays (ebbs, count);
2792 /* now get back the chain */
2793 ic = iCodeLabelOptimize (iCodeFromeBBlock (ebbs, count));
2798 /* free up any _G.stackSpil locations allocated */
2799 applyToSet (_G.stackSpil, deallocStackSpil);
2801 setToNull ((void **) &_G.stackSpil);
2802 setToNull ((void **) &_G.spiltSet);
2803 /* mark all registers as free */