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 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 /* had to position more than once GIVE UP */
1393 /* UNDO all the changes we made to try this */
1395 for (i=0; i < sym->nRegs ; i++ ) {
1396 sym->regs[i] = NULL;
1399 D (fprintf (stderr, "Fill Gap gave up due to positioning for "
1400 "%s in function %s\n",
1401 sym->name, currFunc ? currFunc->name : "UNKNOWN"));
1404 D (fprintf (stderr, "FILLED GAP for %s in function %s\n",
1405 sym->name, currFunc ? currFunc->name : "UNKNOWN"));
1406 _G.totRegAssigned = bitVectSetBit(_G.totRegAssigned,sym->key);
1407 sym->isspilt = sym->spillA = 0 ;
1408 sym->usl.spillLoc->allocreq--;
1413 /*-----------------------------------------------------------------*/
1414 /* rUmaskForOp :- returns register mask for an operand */
1415 /*-----------------------------------------------------------------*/
1417 ds390_rUmaskForOp (operand * op)
1423 /* only temporaries are assigned registers */
1427 sym = OP_SYMBOL (op);
1429 /* if spilt or no registers assigned to it
1431 if (sym->isspilt || !sym->nRegs)
1434 rumask = newBitVect (ds390_nRegs);
1436 for (j = 0; j < sym->nRegs; j++)
1438 rumask = bitVectSetBit (rumask,
1439 sym->regs[j]->rIdx);
1445 /*-----------------------------------------------------------------*/
1446 /* regsUsedIniCode :- returns bit vector of registers used in iCode */
1447 /*-----------------------------------------------------------------*/
1449 regsUsedIniCode (iCode * ic)
1451 bitVect *rmask = newBitVect (ds390_nRegs);
1453 /* do the special cases first */
1456 rmask = bitVectUnion (rmask,
1457 ds390_rUmaskForOp (IC_COND (ic)));
1461 /* for the jumptable */
1462 if (ic->op == JUMPTABLE)
1464 rmask = bitVectUnion (rmask,
1465 ds390_rUmaskForOp (IC_JTCOND (ic)));
1470 /* of all other cases */
1472 rmask = bitVectUnion (rmask,
1473 ds390_rUmaskForOp (IC_LEFT (ic)));
1477 rmask = bitVectUnion (rmask,
1478 ds390_rUmaskForOp (IC_RIGHT (ic)));
1481 rmask = bitVectUnion (rmask,
1482 ds390_rUmaskForOp (IC_RESULT (ic)));
1488 /*-----------------------------------------------------------------*/
1489 /* createRegMask - for each instruction will determine the regsUsed */
1490 /*-----------------------------------------------------------------*/
1492 createRegMask (eBBlock ** ebbs, int count)
1496 /* for all blocks */
1497 for (i = 0; i < count; i++)
1501 if (ebbs[i]->noPath &&
1502 (ebbs[i]->entryLabel != entryLabel &&
1503 ebbs[i]->entryLabel != returnLabel))
1506 /* for all instructions */
1507 for (ic = ebbs[i]->sch; ic; ic = ic->next)
1512 if (SKIP_IC2 (ic) || !ic->rlive)
1515 /* first mark the registers used in this
1517 ic->rUsed = regsUsedIniCode (ic);
1518 _G.funcrUsed = bitVectUnion (_G.funcrUsed, ic->rUsed);
1520 /* now create the register mask for those
1521 registers that are in use : this is a
1522 super set of ic->rUsed */
1523 ic->rMask = newBitVect (ds390_nRegs + 1);
1525 /* for all live Ranges alive at this point */
1526 for (j = 1; j < ic->rlive->size; j++)
1531 /* if not alive then continue */
1532 if (!bitVectBitValue (ic->rlive, j))
1535 /* find the live range we are interested in */
1536 if (!(sym = hTabItemWithKey (liveRanges, j)))
1538 werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
1539 "createRegMask cannot find live range");
1543 /* special case for ruonly */
1544 if (sym->ruonly && sym->liveFrom != sym->liveTo) {
1545 int size = getSize(sym->type);
1547 for (k = 0 ; k < size; k++ )
1548 ic->rMask = bitVectSetBit (ic->rMask, j++);
1551 /* if no register assigned to it */
1552 if (!sym->nRegs || sym->isspilt)
1555 /* for all the registers allocated to it */
1556 for (k = 0; k < sym->nRegs; k++)
1559 bitVectSetBit (ic->rMask, sym->regs[k]->rIdx);
1565 /*-----------------------------------------------------------------*/
1566 /* rematStr - returns the rematerialized string for a remat var */
1567 /*-----------------------------------------------------------------*/
1569 rematStr (symbol * sym)
1572 iCode *ic = sym->rematiCode;
1577 /* if plus or minus print the right hand side */
1578 if (ic->op == '+' || ic->op == '-')
1580 sprintf (s, "0x%04x %c ", (int) operandLitValue (IC_RIGHT (ic)),
1583 ic = OP_SYMBOL (IC_LEFT (ic))->rematiCode;
1586 /* cast then continue */
1587 if (IS_CAST_ICODE(ic)) {
1588 ic = OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
1591 /* we reached the end */
1592 sprintf (s, "%s", OP_SYMBOL (IC_LEFT (ic))->rname);
1599 /*-----------------------------------------------------------------*/
1600 /* regTypeNum - computes the type & number of registers required */
1601 /*-----------------------------------------------------------------*/
1609 /* for each live range do */
1610 for (sym = hTabFirstItem (liveRanges, &k); sym;
1611 sym = hTabNextItem (liveRanges, &k))
1614 /* if used zero times then no registers needed */
1615 if ((sym->liveTo - sym->liveFrom) == 0)
1619 /* if the live range is a temporary */
1623 /* if the type is marked as a conditional */
1624 if (sym->regType == REG_CND)
1627 /* if used in return only then we don't
1629 if (sym->ruonly || sym->accuse)
1631 if (IS_AGGREGATE (sym->type) || sym->isptr)
1632 sym->type = aggrToPtr (sym->type, FALSE);
1636 /* if the symbol has only one definition &
1637 that definition is a get_pointer and the
1638 pointer we are getting is rematerializable and
1641 if (bitVectnBitsOn (sym->defs) == 1 &&
1642 (ic = hTabItemWithKey (iCodehTab,
1643 bitVectFirstBit (sym->defs))) &&
1646 !IS_BITVAR (sym->etype))
1650 /* if remat in data space */
1651 if (OP_SYMBOL (IC_LEFT (ic))->remat &&
1652 !IS_CAST_ICODE(OP_SYMBOL (IC_LEFT (ic))->rematiCode) &&
1653 DCL_TYPE (aggrToPtr (sym->type, FALSE)) == POINTER)
1656 /* create a psuedo symbol & force a spil */
1657 symbol *psym = newSymbol (rematStr (OP_SYMBOL (IC_LEFT (ic))), 1);
1658 psym->type = sym->type;
1659 psym->etype = sym->etype;
1660 strcpy (psym->rname, psym->name);
1662 sym->usl.spillLoc = psym;
1666 /* if in data space or idata space then try to
1667 allocate pointer register */
1671 /* if not then we require registers */
1672 sym->nRegs = ((IS_AGGREGATE (sym->type) || sym->isptr) ?
1673 getSize (sym->type = aggrToPtr (sym->type, FALSE)) :
1674 getSize (sym->type));
1678 fprintf (stderr, "allocated more than 4 or 0 registers for type ");
1679 printTypeChain (sym->type, stderr);
1680 fprintf (stderr, "\n");
1683 /* determine the type of register required */
1684 if (sym->nRegs == 1 &&
1685 IS_PTR (sym->type) &&
1687 sym->regType = REG_PTR;
1689 sym->regType = REG_GPR;
1693 /* for the first run we don't provide */
1694 /* registers for true symbols we will */
1695 /* see how things go */
1701 /*-----------------------------------------------------------------*/
1702 /* freeAllRegs - mark all registers as free */
1703 /*-----------------------------------------------------------------*/
1709 for (i = 0; i < ds390_nRegs; i++)
1710 regs390[i].isFree = 1;
1713 /*-----------------------------------------------------------------*/
1714 /* deallocStackSpil - this will set the stack pointer back */
1715 /*-----------------------------------------------------------------*/
1717 DEFSETFUNC (deallocStackSpil)
1725 /*-----------------------------------------------------------------*/
1726 /* farSpacePackable - returns the packable icode for far variables */
1727 /*-----------------------------------------------------------------*/
1729 farSpacePackable (iCode * ic)
1733 /* go thru till we find a definition for the
1734 symbol on the right */
1735 for (dic = ic->prev; dic; dic = dic->prev)
1738 /* if the definition is a call then no */
1739 if ((dic->op == CALL || dic->op == PCALL) &&
1740 IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
1745 /* if shift by unknown amount then not */
1746 if ((dic->op == LEFT_OP || dic->op == RIGHT_OP) &&
1747 IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
1750 /* if pointer get and size > 1 */
1751 if (POINTER_GET (dic) &&
1752 getSize (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)) > 1)
1755 if (POINTER_SET (dic) &&
1756 getSize (aggrToPtr (operandType (IC_RESULT (dic)), FALSE)) > 1)
1759 /* if any three is a true symbol in far space */
1760 if (IC_RESULT (dic) &&
1761 IS_TRUE_SYMOP (IC_RESULT (dic)) &&
1762 isOperandInFarSpace (IC_RESULT (dic)))
1765 if (IC_RIGHT (dic) &&
1766 IS_TRUE_SYMOP (IC_RIGHT (dic)) &&
1767 isOperandInFarSpace (IC_RIGHT (dic)) &&
1768 !isOperandEqual (IC_RIGHT (dic), IC_RESULT (ic)))
1771 if (IC_LEFT (dic) &&
1772 IS_TRUE_SYMOP (IC_LEFT (dic)) &&
1773 isOperandInFarSpace (IC_LEFT (dic)) &&
1774 !isOperandEqual (IC_LEFT (dic), IC_RESULT (ic)))
1777 if (isOperandEqual (IC_RIGHT (ic), IC_RESULT (dic)))
1779 if ((dic->op == LEFT_OP ||
1780 dic->op == RIGHT_OP ||
1782 IS_OP_LITERAL (IC_RIGHT (dic)))
1792 /*-----------------------------------------------------------------*/
1793 /* packRegsForAssign - register reduction for assignment */
1794 /*-----------------------------------------------------------------*/
1796 packRegsForAssign (iCode * ic, eBBlock * ebp)
1800 if (!IS_ITEMP (IC_RIGHT (ic)) ||
1801 OP_SYMBOL (IC_RIGHT (ic))->isind ||
1802 OP_LIVETO (IC_RIGHT (ic)) > ic->seq)
1807 /* if the true symbol is defined in far space or on stack
1808 then we should not since this will increase register pressure */
1810 if (isOperandInFarSpace (IC_RESULT (ic)))
1812 if ((dic = farSpacePackable (ic)))
1818 if (isOperandInFarSpace(IC_RESULT(ic)) && !farSpacePackable(ic)) {
1823 /* find the definition of iTempNN scanning backwards if we find a
1824 a use of the true symbol in before we find the definition then
1826 for (dic = ic->prev; dic; dic = dic->prev)
1828 /* if there is a function call then don't pack it */
1829 if ((dic->op == CALL || dic->op == PCALL))
1838 if (IS_TRUE_SYMOP (IC_RESULT (dic)) &&
1839 IS_OP_VOLATILE (IC_RESULT (dic)))
1845 if (IS_SYMOP (IC_RESULT (dic)) &&
1846 IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
1848 if (POINTER_SET (dic))
1854 if (IS_SYMOP (IC_RIGHT (dic)) &&
1855 (IC_RIGHT (dic)->key == IC_RESULT (ic)->key ||
1856 IC_RIGHT (dic)->key == IC_RIGHT (ic)->key))
1862 if (IS_SYMOP (IC_LEFT (dic)) &&
1863 (IC_LEFT (dic)->key == IC_RESULT (ic)->key ||
1864 IC_LEFT (dic)->key == IC_RIGHT (ic)->key))
1870 if (POINTER_SET (dic) &&
1871 IC_RESULT (dic)->key == IC_RESULT (ic)->key)
1879 return 0; /* did not find */
1881 /* if the result is on stack or iaccess then it must be
1882 the same atleast one of the operands */
1883 if (OP_SYMBOL (IC_RESULT (ic))->onStack ||
1884 OP_SYMBOL (IC_RESULT (ic))->iaccess)
1887 /* the operation has only one symbol
1888 operator then we can pack */
1889 if ((IC_LEFT (dic) && !IS_SYMOP (IC_LEFT (dic))) ||
1890 (IC_RIGHT (dic) && !IS_SYMOP (IC_RIGHT (dic))))
1893 if (!((IC_LEFT (dic) &&
1894 IC_RESULT (ic)->key == IC_LEFT (dic)->key) ||
1896 IC_RESULT (ic)->key == IC_RIGHT (dic)->key)))
1900 /* found the definition */
1901 /* replace the result with the result of */
1902 /* this assignment and remove this assignment */
1903 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
1904 IC_RESULT (dic) = IC_RESULT (ic);
1906 if (IS_ITEMP (IC_RESULT (dic)) && OP_SYMBOL (IC_RESULT (dic))->liveFrom > dic->seq)
1908 OP_SYMBOL (IC_RESULT (dic))->liveFrom = dic->seq;
1910 /* delete from liverange table also
1911 delete from all the points inbetween and the new
1913 for (sic = dic; sic != ic; sic = sic->next)
1915 bitVectUnSetBit (sic->rlive, IC_RESULT (ic)->key);
1916 if (IS_ITEMP (IC_RESULT (dic)))
1917 bitVectSetBit (sic->rlive, IC_RESULT (dic)->key);
1920 remiCodeFromeBBlock (ebp, ic);
1921 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
1922 hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
1923 OP_DEFS (IC_RESULT (dic)) = bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
1928 /*-----------------------------------------------------------------*/
1929 /* findAssignToSym : scanning backwards looks for first assig found */
1930 /*-----------------------------------------------------------------*/
1932 findAssignToSym (operand * op, iCode * ic)
1936 for (dic = ic->prev; dic; dic = dic->prev)
1939 /* if definition by assignment */
1940 if (dic->op == '=' &&
1941 !POINTER_SET (dic) &&
1942 IC_RESULT (dic)->key == op->key
1943 /* && IS_TRUE_SYMOP(IC_RIGHT(dic)) */
1947 /* we are interested only if defined in far space */
1948 /* or in stack space in case of + & - */
1950 /* if assigned to a non-symbol then return
1952 if (!IS_SYMOP (IC_RIGHT (dic)))
1955 /* if the symbol is in far space then
1957 if (isOperandInFarSpace (IC_RIGHT (dic)))
1960 /* for + & - operations make sure that
1961 if it is on the stack it is the same
1962 as one of the three operands */
1963 if ((ic->op == '+' || ic->op == '-') &&
1964 OP_SYMBOL (IC_RIGHT (dic))->onStack)
1967 if (IC_RESULT (ic)->key != IC_RIGHT (dic)->key &&
1968 IC_LEFT (ic)->key != IC_RIGHT (dic)->key &&
1969 IC_RIGHT (ic)->key != IC_RIGHT (dic)->key)
1977 /* if we find an usage then we cannot delete it */
1978 if (IC_LEFT (dic) && IC_LEFT (dic)->key == op->key)
1981 if (IC_RIGHT (dic) && IC_RIGHT (dic)->key == op->key)
1984 if (POINTER_SET (dic) && IC_RESULT (dic)->key == op->key)
1988 /* now make sure that the right side of dic
1989 is not defined between ic & dic */
1992 iCode *sic = dic->next;
1994 for (; sic != ic; sic = sic->next)
1995 if (IC_RESULT (sic) &&
1996 IC_RESULT (sic)->key == IC_RIGHT (dic)->key)
2005 /*-----------------------------------------------------------------*/
2006 /* packRegsForSupport :- reduce some registers for support calls */
2007 /*-----------------------------------------------------------------*/
2009 packRegsForSupport (iCode * ic, eBBlock * ebp)
2012 /* for the left & right operand :- look to see if the
2013 left was assigned a true symbol in far space in that
2014 case replace them */
2015 if (IS_ITEMP (IC_LEFT (ic)) &&
2016 OP_SYMBOL (IC_LEFT (ic))->liveTo <= ic->seq)
2018 iCode *dic = findAssignToSym (IC_LEFT (ic), ic);
2024 /* found it we need to remove it from the
2026 for (sic = dic; sic != ic; sic = sic->next)
2027 bitVectUnSetBit (sic->rlive, IC_LEFT (ic)->key);
2029 IC_LEFT (ic)->operand.symOperand =
2030 IC_RIGHT (dic)->operand.symOperand;
2031 IC_LEFT (ic)->key = IC_RIGHT (dic)->operand.symOperand->key;
2032 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2033 remiCodeFromeBBlock (ebp, dic);
2034 hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2038 /* do the same for the right operand */
2041 IS_ITEMP (IC_RIGHT (ic)) &&
2042 OP_SYMBOL (IC_RIGHT (ic))->liveTo <= ic->seq)
2044 iCode *dic = findAssignToSym (IC_RIGHT (ic), ic);
2050 /* if this is a subtraction & the result
2051 is a true symbol in far space then don't pack */
2052 if (ic->op == '-' && IS_TRUE_SYMOP (IC_RESULT (dic)))
2054 sym_link *etype = getSpec (operandType (IC_RESULT (dic)));
2055 if (IN_FARSPACE (SPEC_OCLS (etype)))
2058 /* found it we need to remove it from the
2060 for (sic = dic; sic != ic; sic = sic->next)
2061 bitVectUnSetBit (sic->rlive, IC_RIGHT (ic)->key);
2063 IC_RIGHT (ic)->operand.symOperand =
2064 IC_RIGHT (dic)->operand.symOperand;
2065 IC_RIGHT (ic)->key = IC_RIGHT (dic)->operand.symOperand->key;
2067 remiCodeFromeBBlock (ebp, dic);
2068 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2069 hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2076 #define IS_OP_RUONLY(x) (x && IS_SYMOP(x) && OP_SYMBOL(x)->ruonly)
2079 /*-----------------------------------------------------------------*/
2080 /* packRegsDPTRuse : - will reduce some registers for single Use */
2081 /*-----------------------------------------------------------------*/
2083 packRegsDPTRuse (operand * op)
2085 /* go thru entire liveRange of this variable & check for
2086 other possible usage of DPTR , if we don't find it the
2087 assign this to DPTR (ruonly)
2092 sym_link *type, *etype;
2094 if (!IS_SYMOP(op) || !IS_ITEMP(op)) return NULL;
2095 if (OP_SYMBOL(op)->remat || OP_SYMBOL(op)->ruonly) return NULL;
2097 /* first check if any overlapping liverange has already been
2099 if (OP_SYMBOL(op)->clashes) {
2100 for (i = 0 ; i < OP_SYMBOL(op)->clashes->size ; i++ ) {
2101 if (bitVectBitValue(OP_SYMBOL(op)->clashes,i)) {
2102 sym = hTabItemWithKey(liveRanges,i);
2103 if (sym->ruonly) return NULL ;
2108 /* no then go thru this guys live range */
2109 dic = ic = hTabFirstItemWK(iCodeSeqhTab,OP_SYMBOL(op)->liveFrom);
2110 for (; ic && ic->seq <= OP_SYMBOL(op)->liveTo;
2111 ic = hTabNextItem(iCodeSeqhTab,&key)) {
2113 if (SKIP_IC3(ic)) continue;
2115 /* if PCALL cannot be sure give up */
2116 if (ic->op == PCALL) return NULL;
2118 /* if CALL then make sure it is VOID || return value not used
2119 or the return value is assigned to this one */
2120 if (ic->op == CALL) {
2121 if (OP_SYMBOL(IC_RESULT(ic))->liveTo ==
2122 OP_SYMBOL(IC_RESULT(ic))->liveFrom) continue ;
2123 etype = getSpec(type = operandType(IC_RESULT(ic)));
2124 //if (getSize(type) == 0 || isOperandEqual(op,IC_RESULT(ic)))
2125 if (getSize(type) == 0)
2130 /* special case of add with a [remat] */
2131 if (ic->op == '+' &&
2132 OP_SYMBOL(IC_LEFT(ic))->remat &&
2133 (isOperandInFarSpace(IC_RIGHT(ic)) &&
2134 !isOperandInReg(IC_RIGHT(ic)))) return NULL ;
2138 if (POINTER_GET(ic) && !isOperandEqual(IC_LEFT(ic),op) &&
2139 getSize(operandType(IC_LEFT(ic))) > 1 ) return NULL ;
2142 if (POINTER_SET(ic) && !isOperandEqual(IC_RESULT(ic),op) &&
2143 getSize(operandType(IC_RESULT(ic))) > 1 ) return NULL;
2145 /* conditionals can destroy 'b' - make sure B wont be used in this one*/
2146 if ((IS_CONDITIONAL(ic) || ic->op == '*' || ic->op == '/' ) &&
2147 getSize(operandType(op)) > 3) return NULL;
2150 if (IC_RESULT(ic) && IS_SYMOP(IC_RESULT(ic)) &&
2151 !isOperandEqual(IC_RESULT(ic),op) &&
2152 ((isOperandInFarSpace(IC_RESULT(ic)) && !isOperandInReg(IC_RESULT(ic))) ||
2153 OP_SYMBOL(IC_RESULT(ic))->ruonly ||
2154 OP_SYMBOL(IC_RESULT(ic))->onStack)) return NULL;
2156 if (IC_RIGHT(ic) && IS_SYMOP(IC_RIGHT(ic)) &&
2157 !isOperandEqual(IC_RIGHT(ic),op) &&
2158 (OP_SYMBOL(IC_RIGHT(ic))->liveTo > ic->seq ||
2159 IS_TRUE_SYMOP(IC_RIGHT(ic)) ||
2160 OP_SYMBOL(IC_RIGHT(ic))->ruonly) &&
2161 ((isOperandInFarSpace(IC_RIGHT(ic)) && !isOperandInReg(IC_RIGHT(ic)))||
2162 OP_SYMBOL(IC_RIGHT(ic))->onStack)) return NULL;
2164 if (IC_LEFT(ic) && IS_SYMOP(IC_LEFT(ic)) &&
2165 !isOperandEqual(IC_LEFT(ic),op) &&
2166 (OP_SYMBOL(IC_LEFT(ic))->liveTo > ic->seq ||
2167 IS_TRUE_SYMOP(IC_LEFT(ic)) ||
2168 OP_SYMBOL(IC_LEFT(ic))->ruonly) &&
2169 ((isOperandInFarSpace(IC_LEFT(ic)) && !isOperandInReg(IC_LEFT(ic)))||
2170 OP_SYMBOL(IC_LEFT(ic))->onStack)) return NULL;
2172 if (IC_LEFT(ic) && IC_RIGHT(ic) &&
2173 IS_ITEMP(IC_LEFT(ic)) && IS_ITEMP(IC_RIGHT(ic)) &&
2174 (isOperandInFarSpace(IC_LEFT(ic)) && !isOperandInReg(IC_LEFT(ic))) &&
2175 (isOperandInFarSpace(IC_RIGHT(ic)) && !isOperandInReg(IC_RIGHT(ic))))
2178 OP_SYMBOL(op)->ruonly = 1;
2182 /*-----------------------------------------------------------------*/
2183 /* isBitwiseOptimizable - requirements of JEAN LOUIS VERN */
2184 /*-----------------------------------------------------------------*/
2186 isBitwiseOptimizable (iCode * ic)
2188 sym_link *ltype = getSpec (operandType (IC_LEFT (ic)));
2189 sym_link *rtype = getSpec (operandType (IC_RIGHT (ic)));
2191 /* bitwise operations are considered optimizable
2192 under the following conditions (Jean-Louis VERN)
2204 if ( IS_LITERAL (rtype) ||
2205 (IS_BITVAR (ltype) && IN_BITSPACE (SPEC_OCLS (ltype))))
2211 /*-----------------------------------------------------------------*/
2212 /* packRegsForAccUse - pack registers for acc use */
2213 /*-----------------------------------------------------------------*/
2215 packRegsForAccUse (iCode * ic)
2219 /* if this is an aggregate, e.g. a one byte char array */
2220 if (IS_AGGREGATE(operandType(IC_RESULT(ic)))) {
2224 /* if + or - then it has to be one byte result */
2225 if ((ic->op == '+' || ic->op == '-')
2226 && getSize (operandType (IC_RESULT (ic))) > 1)
2229 /* if shift operation make sure right side is not a literal */
2230 if (ic->op == RIGHT_OP &&
2231 (isOperandLiteral (IC_RIGHT (ic)) ||
2232 getSize (operandType (IC_RESULT (ic))) > 1))
2235 if (ic->op == LEFT_OP &&
2236 (isOperandLiteral (IC_RIGHT (ic)) ||
2237 getSize (operandType (IC_RESULT (ic))) > 1))
2240 if (IS_BITWISE_OP (ic) &&
2241 getSize (operandType (IC_RESULT (ic))) > 1)
2245 /* has only one definition */
2246 if (bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) > 1)
2249 /* has only one use */
2250 if (bitVectnBitsOn (OP_USES (IC_RESULT (ic))) > 1)
2253 /* and the usage immediately follows this iCode */
2254 if (!(uic = hTabItemWithKey (iCodehTab,
2255 bitVectFirstBit (OP_USES (IC_RESULT (ic))))))
2258 if (ic->next != uic)
2261 /* if it is a conditional branch then we definitely can */
2265 if (uic->op == JUMPTABLE)
2268 /* if the usage is not is an assignment
2269 or an arithmetic / bitwise / shift operation then not */
2270 if (POINTER_SET (uic) &&
2271 getSize (aggrToPtr (operandType (IC_RESULT (uic)), FALSE)) > 1)
2274 if (uic->op != '=' &&
2275 !IS_ARITHMETIC_OP (uic) &&
2276 !IS_BITWISE_OP (uic) &&
2277 uic->op != LEFT_OP &&
2278 uic->op != RIGHT_OP)
2281 /* if used in ^ operation then make sure right is not a
2283 if (uic->op == '^' && isOperandLiteral (IC_RIGHT (uic)))
2286 /* if shift operation make sure right side is not a literal */
2287 if (uic->op == RIGHT_OP &&
2288 (isOperandLiteral (IC_RIGHT (uic)) ||
2289 getSize (operandType (IC_RESULT (uic))) > 1))
2292 if (uic->op == LEFT_OP &&
2293 (isOperandLiteral (IC_RIGHT (uic)) ||
2294 getSize (operandType (IC_RESULT (uic))) > 1))
2297 /* make sure that the result of this icode is not on the
2298 stack, since acc is used to compute stack offset */
2300 if (IS_TRUE_SYMOP (IC_RESULT (uic)) &&
2301 OP_SYMBOL (IC_RESULT (uic))->onStack)
2304 if (isOperandOnStack(IC_RESULT(uic)))
2308 /* if either one of them in far space then we cannot */
2309 if ((IS_TRUE_SYMOP (IC_LEFT (uic)) &&
2310 isOperandInFarSpace (IC_LEFT (uic))) ||
2311 (IS_TRUE_SYMOP (IC_RIGHT (uic)) &&
2312 isOperandInFarSpace (IC_RIGHT (uic))))
2315 /* if the usage has only one operand then we can */
2316 if (IC_LEFT (uic) == NULL ||
2317 IC_RIGHT (uic) == NULL)
2320 /* make sure this is on the left side if not
2321 a '+' since '+' is commutative */
2322 if (ic->op != '+' &&
2323 IC_LEFT (uic)->key != IC_RESULT (ic)->key)
2327 // this is too dangerous and need further restrictions
2330 /* if one of them is a literal then we can */
2331 if ((IC_LEFT (uic) && IS_OP_LITERAL (IC_LEFT (uic))) ||
2332 (IC_RIGHT (uic) && IS_OP_LITERAL (IC_RIGHT (uic))))
2334 OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
2339 /* if the other one is not on stack then we can */
2340 if (IC_LEFT (uic)->key == IC_RESULT (ic)->key &&
2341 (IS_ITEMP (IC_RIGHT (uic)) ||
2342 (IS_TRUE_SYMOP (IC_RIGHT (uic)) &&
2343 !OP_SYMBOL (IC_RIGHT (uic))->onStack)))
2346 if (IC_RIGHT (uic)->key == IC_RESULT (ic)->key &&
2347 (IS_ITEMP (IC_LEFT (uic)) ||
2348 (IS_TRUE_SYMOP (IC_LEFT (uic)) &&
2349 !OP_SYMBOL (IC_LEFT (uic))->onStack)))
2355 OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
2360 /*-----------------------------------------------------------------*/
2361 /* packForPush - hueristics to reduce iCode for pushing */
2362 /*-----------------------------------------------------------------*/
2364 packForPush (iCode * ic, eBBlock * ebp)
2369 if (ic->op != IPUSH || !IS_ITEMP (IC_LEFT (ic)))
2372 /* must have only definition & one usage */
2373 if (bitVectnBitsOn (OP_DEFS (IC_LEFT (ic))) != 1 ||
2374 bitVectnBitsOn (OP_USES (IC_LEFT (ic))) != 1)
2377 /* find the definition */
2378 if (!(dic = hTabItemWithKey (iCodehTab,
2379 bitVectFirstBit (OP_DEFS (IC_LEFT (ic))))))
2382 if (dic->op != '=' || POINTER_SET (dic))
2385 /* make sure the right side does not have any definitions
2387 dbv = OP_DEFS(IC_RIGHT(dic));
2388 for (lic = ic; lic && lic != dic ; lic = lic->prev) {
2389 if (bitVectBitValue(dbv,lic->key)) return ;
2391 /* make sure they have the same type */
2393 sym_link *itype=operandType(IC_LEFT(ic));
2394 sym_link *ditype=operandType(IC_RIGHT(dic));
2396 if (SPEC_USIGN(itype)!=SPEC_USIGN(ditype) ||
2397 SPEC_LONG(itype)!=SPEC_LONG(ditype))
2400 /* extend the live range of replaced operand if needed */
2401 if (OP_SYMBOL(IC_RIGHT(dic))->liveTo < ic->seq) {
2402 OP_SYMBOL(IC_RIGHT(dic))->liveTo = ic->seq;
2404 /* we now we know that it has one & only one def & use
2405 and the that the definition is an assignment */
2406 IC_LEFT (ic) = IC_RIGHT (dic);
2408 remiCodeFromeBBlock (ebp, dic);
2409 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2410 hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2413 /*-----------------------------------------------------------------*/
2414 /* packRegisters - does some transformations to reduce register */
2416 /*-----------------------------------------------------------------*/
2418 packRegisters (eBBlock * ebp)
2428 /* look for assignments of the form */
2429 /* iTempNN = TRueSym (someoperation) SomeOperand */
2431 /* TrueSym := iTempNN:1 */
2432 for (ic = ebp->sch; ic; ic = ic->next)
2436 /* find assignment of the form TrueSym := iTempNN:1 */
2437 if (ic->op == '=' && !POINTER_SET (ic))
2438 change += packRegsForAssign (ic, ebp);
2445 for (ic = ebp->sch; ic; ic = ic->next)
2448 /* if this is an itemp & result of a address of a true sym
2449 then mark this as rematerialisable */
2450 if (ic->op == ADDRESS_OF &&
2451 IS_ITEMP (IC_RESULT (ic)) &&
2452 IS_TRUE_SYMOP (IC_LEFT (ic)) &&
2453 bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
2454 !OP_SYMBOL (IC_LEFT (ic))->onStack)
2457 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2458 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2459 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2463 /* if straight assignment then carry remat flag if
2464 this is the only definition */
2465 if (ic->op == '=' &&
2466 !POINTER_SET (ic) &&
2467 IS_SYMOP (IC_RIGHT (ic)) &&
2468 OP_SYMBOL (IC_RIGHT (ic))->remat &&
2469 !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode) &&
2470 bitVectnBitsOn (OP_SYMBOL (IC_RESULT (ic))->defs) <= 1)
2473 OP_SYMBOL (IC_RESULT (ic))->remat =
2474 OP_SYMBOL (IC_RIGHT (ic))->remat;
2475 OP_SYMBOL (IC_RESULT (ic))->rematiCode =
2476 OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
2479 /* if cast to a generic pointer & the pointer being
2480 cast is remat, then we can remat this cast as well */
2481 if (ic->op == CAST &&
2482 IS_SYMOP(IC_RIGHT(ic)) &&
2483 OP_SYMBOL(IC_RIGHT(ic))->remat ) {
2484 sym_link *to_type = operandType(IC_LEFT(ic));
2485 sym_link *from_type = operandType(IC_RIGHT(ic));
2486 if (IS_GENPTR(to_type) && IS_PTR(from_type)) {
2487 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2488 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2489 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2493 /* if this is a +/- operation with a rematerizable
2494 then mark this as rematerializable as well */
2495 if ((ic->op == '+' || ic->op == '-') &&
2496 (IS_SYMOP (IC_LEFT (ic)) &&
2497 IS_ITEMP (IC_RESULT (ic)) &&
2498 OP_SYMBOL (IC_LEFT (ic))->remat &&
2499 (!IS_SYMOP (IC_RIGHT (ic)) || !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode)) &&
2500 bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
2501 IS_OP_LITERAL (IC_RIGHT (ic))))
2504 //int i = operandLitValue(IC_RIGHT(ic));
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;
2510 /* mark the pointer usages */
2511 if (POINTER_SET (ic))
2512 OP_SYMBOL (IC_RESULT (ic))->uptr = 1;
2514 if (POINTER_GET (ic))
2515 OP_SYMBOL (IC_LEFT (ic))->uptr = 1;
2517 if (ic->op == RETURN && IS_SYMOP (IC_LEFT(ic)))
2518 OP_SYMBOL (IC_LEFT (ic))->uptr = 1;
2522 /* if we are using a symbol on the stack
2523 then we should say ds390_ptrRegReq */
2524 if (ic->op == IFX && IS_SYMOP (IC_COND (ic)))
2525 ds390_ptrRegReq += ((OP_SYMBOL (IC_COND (ic))->onStack ? !options.stack10bit : 0) +
2526 OP_SYMBOL (IC_COND (ic))->iaccess);
2527 else if (ic->op == JUMPTABLE && IS_SYMOP (IC_JTCOND (ic)))
2528 ds390_ptrRegReq += ((OP_SYMBOL (IC_JTCOND (ic))->onStack ? !options.stack10bit : 0) +
2529 OP_SYMBOL (IC_JTCOND (ic))->iaccess);
2532 if (IS_SYMOP (IC_LEFT (ic)))
2533 ds390_ptrRegReq += ((OP_SYMBOL (IC_LEFT (ic))->onStack ? !options.stack10bit : 0) +
2534 OP_SYMBOL (IC_LEFT (ic))->iaccess);
2535 if (IS_SYMOP (IC_RIGHT (ic)))
2536 ds390_ptrRegReq += ((OP_SYMBOL (IC_RIGHT (ic))->onStack ? !options.stack10bit : 0) +
2537 OP_SYMBOL (IC_RIGHT (ic))->iaccess);
2538 if (IS_SYMOP (IC_RESULT (ic)))
2539 ds390_ptrRegReq += ((OP_SYMBOL (IC_RESULT (ic))->onStack ? !options.stack10bit : 0) +
2540 OP_SYMBOL (IC_RESULT (ic))->iaccess);
2545 /* if the condition of an if instruction
2546 is defined in the previous instruction then
2547 mark the itemp as a conditional */
2548 if ((IS_CONDITIONAL (ic) ||
2549 (IS_BITWISE_OP(ic) && isBitwiseOptimizable(ic))) &&
2550 ic->next && ic->next->op == IFX &&
2551 isOperandEqual (IC_RESULT (ic), IC_COND (ic->next)) &&
2552 OP_SYMBOL (IC_RESULT (ic))->liveTo <= ic->next->seq)
2555 OP_SYMBOL (IC_RESULT (ic))->regType = REG_CND;
2559 /* if the condition of an if instruction
2560 is defined in the previous instruction and
2561 this is the only usage then
2562 mark the itemp as a conditional */
2563 if ((IS_CONDITIONAL (ic) ||
2564 (IS_BITWISE_OP(ic) && isBitwiseOptimizable (ic))) &&
2565 ic->next && ic->next->op == IFX &&
2566 bitVectnBitsOn (OP_USES(IC_RESULT(ic)))==1 &&
2567 isOperandEqual (IC_RESULT (ic), IC_COND (ic->next)) &&
2568 OP_SYMBOL (IC_RESULT (ic))->liveTo <= ic->next->seq)
2570 OP_SYMBOL (IC_RESULT (ic))->regType = REG_CND;
2575 /* reduce for support function calls */
2576 if (ic->supportRtn || ic->op == '+' || ic->op == '-')
2577 packRegsForSupport (ic, ebp);
2579 /* some cases the redundant moves can
2580 can be eliminated for return statements */
2581 if ((ic->op == RETURN || ic->op == SEND) &&
2582 !isOperandInFarSpace (IC_LEFT (ic)) &&
2585 packRegsDPTRuse (IC_LEFT (ic));
2588 if ((ic->op == CALL && getSize(operandType(IC_RESULT(ic))) <= 4)) {
2589 packRegsDPTRuse (IC_RESULT (ic));
2592 /* if pointer set & left has a size more than
2593 one and right is not in far space */
2594 if (POINTER_SET (ic) &&
2595 !isOperandInFarSpace (IC_RIGHT (ic)) &&
2596 !OP_SYMBOL (IC_RESULT (ic))->remat &&
2597 !IS_OP_RUONLY (IC_RIGHT (ic)) &&
2598 getSize (aggrToPtr (operandType (IC_RESULT (ic)), FALSE)) > 1) {
2600 packRegsDPTRuse (IC_RESULT (ic));
2603 /* if pointer get */
2604 if (POINTER_GET (ic) &&
2605 !isOperandInFarSpace (IC_RESULT (ic)) &&
2606 !OP_SYMBOL (IC_LEFT (ic))->remat &&
2607 !IS_OP_RUONLY (IC_RESULT (ic)) &&
2608 getSize (aggrToPtr (operandType (IC_LEFT (ic)), FALSE)) > 1) {
2610 packRegsDPTRuse (IC_LEFT (ic));
2613 /* if this is cast for intergral promotion then
2614 check if only use of the definition of the
2615 operand being casted/ if yes then replace
2616 the result of that arithmetic operation with
2617 this result and get rid of the cast */
2620 sym_link *fromType = operandType (IC_RIGHT (ic));
2621 sym_link *toType = operandType (IC_LEFT (ic));
2623 if (IS_INTEGRAL (fromType) && IS_INTEGRAL (toType) &&
2624 getSize (fromType) != getSize (toType) &&
2625 SPEC_USIGN (fromType) == SPEC_USIGN (toType))
2628 iCode *dic = packRegsDPTRuse (IC_RIGHT (ic));
2631 if (IS_ARITHMETIC_OP (dic))
2633 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2634 IC_RESULT (dic) = IC_RESULT (ic);
2635 remiCodeFromeBBlock (ebp, ic);
2636 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
2637 hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
2638 OP_DEFS (IC_RESULT (dic)) = bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
2642 OP_SYMBOL (IC_RIGHT (ic))->ruonly = 0;
2648 /* if the type from and type to are the same
2649 then if this is the only use then packit */
2650 if (compareType (operandType (IC_RIGHT (ic)),
2651 operandType (IC_LEFT (ic))) == 1)
2653 iCode *dic = packRegsDPTRuse (IC_RIGHT (ic));
2656 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
2657 IC_RESULT (dic) = IC_RESULT (ic);
2658 remiCodeFromeBBlock (ebp, ic);
2659 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
2660 hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
2661 OP_DEFS (IC_RESULT (dic)) = bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
2669 iTempNN := (some variable in farspace) V1
2674 if (ic->op == IPUSH)
2676 packForPush (ic, ebp);
2680 /* pack registers for accumulator use, when the
2681 result of an arithmetic or bit wise operation
2682 has only one use, that use is immediately following
2683 the defintion and the using iCode has only one
2684 operand or has two operands but one is literal &
2685 the result of that operation is not on stack then
2686 we can leave the result of this operation in acc:b
2688 if ((IS_ARITHMETIC_OP (ic)
2689 || IS_CONDITIONAL(ic)
2690 || IS_BITWISE_OP (ic)
2691 || ic->op == LEFT_OP || ic->op == RIGHT_OP || ic->op == CALL
2692 || (ic->op == ADDRESS_OF && isOperandOnStack (IC_LEFT (ic)))
2694 IS_ITEMP (IC_RESULT (ic)) &&
2695 getSize (operandType (IC_RESULT (ic))) <= 2)
2697 packRegsForAccUse (ic);
2702 /*-----------------------------------------------------------------*/
2703 /* assignRegisters - assigns registers to each live range as need */
2704 /*-----------------------------------------------------------------*/
2706 ds390_assignRegisters (eBBlock ** ebbs, int count)
2711 setToNull ((void *) &_G.funcrUsed);
2712 setToNull ((void *) &_G.regAssigned);
2713 setToNull ((void *) &_G.totRegAssigned);
2714 setToNull ((void *) &_G.funcrUsed);
2715 ds390_ptrRegReq = _G.stackExtend = _G.dataExtend = 0;
2717 if (options.model != MODEL_FLAT24) options.stack10bit = 0;
2718 /* change assignments this will remove some
2719 live ranges reducing some register pressure */
2720 for (i = 0; i < count; i++)
2721 packRegisters (ebbs[i]);
2723 if (options.dump_pack)
2724 dumpEbbsToFileExt (DUMP_PACK, ebbs, count);
2726 /* first determine for each live range the number of
2727 registers & the type of registers required for each */
2730 /* and serially allocate registers */
2731 serialRegAssign (ebbs, count);
2738 /* if stack was extended then tell the user */
2741 /* werror(W_TOOMANY_SPILS,"stack", */
2742 /* _G.stackExtend,currFunc->name,""); */
2748 /* werror(W_TOOMANY_SPILS,"data space", */
2749 /* _G.dataExtend,currFunc->name,""); */
2753 /* after that create the register mask
2754 for each of the instruction */
2755 createRegMask (ebbs, count);
2757 /* redo that offsets for stacked automatic variables */
2758 redoStackOffsets ();
2760 if (options.dump_rassgn) {
2761 dumpEbbsToFileExt (DUMP_RASSGN, ebbs, count);
2762 dumpLiveRanges (DUMP_LRANGE, liveRanges);
2765 /* do the overlaysegment stuff SDCCmem.c */
2766 doOverlays (ebbs, count);
2768 /* now get back the chain */
2769 ic = iCodeLabelOptimize (iCodeFromeBBlock (ebbs, count));
2774 /* free up any _G.stackSpil locations allocated */
2775 applyToSet (_G.stackSpil, deallocStackSpil);
2777 setToNull ((void **) &_G.stackSpil);
2778 setToNull ((void **) &_G.spiltSet);
2779 /* mark all registers as free */