1 /*------------------------------------------------------------------------
3 SDCCralloc.c - source file for register allocation. (DS80C390) 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", "psw", "xreg", 0, 0, 0},
81 {0, DPL1_IDX, 0, "dpl1", "dpl1", "dpl1", 0, 0, 0},
82 {0, DPH1_IDX, 0, "dph1", "dph1", "dph1", 0, 0, 0},
83 {0, DPX1_IDX, 0, "dpx1", "dpx1", "dpx1", 0, 0, 0},
84 {0, DPS_IDX, 0, "dps", "dps", "dps", 0, 0, 0},
85 {0, A_IDX, 0, "a", "acc", "acc", 0, 0, 0},
86 {0, AP_IDX, 0, "ap", "ap", "ap", 0, 0, 0},
89 static void spillThis (symbol *);
90 static void freeAllRegs ();
91 static iCode * packRegsDPTRuse (operand *);
92 static int packRegsDPTRnuse (operand *,unsigned);
94 /*-----------------------------------------------------------------*/
95 /* allocReg - allocates register of given type */
96 /*-----------------------------------------------------------------*/
102 for (i = 0; i < ds390_nRegs; i++)
105 /* if type is given as 0 then any
106 free register will do */
110 regs390[i].isFree = 0;
113 bitVectSetBit (currFunc->regsUsed, i);
116 /* other wise look for specific type
118 if (regs390[i].isFree &&
119 regs390[i].type == type)
121 regs390[i].isFree = 0;
124 bitVectSetBit (currFunc->regsUsed, i);
131 /*-----------------------------------------------------------------*/
132 /* ds390_regWithIdx - returns pointer to register with index number*/
133 /*-----------------------------------------------------------------*/
135 ds390_regWithIdx (int idx)
139 for (i = 0; i < sizeof(regs390)/sizeof(regs); i++)
140 if (regs390[i].rIdx == idx)
143 werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
144 "regWithIdx not found");
148 /*-----------------------------------------------------------------*/
149 /* freeReg - frees a register */
150 /*-----------------------------------------------------------------*/
156 werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
157 "freeReg - Freeing NULL register");
164 /*-----------------------------------------------------------------*/
165 /* useReg - marks a register as used */
166 /*-----------------------------------------------------------------*/
174 /*-----------------------------------------------------------------*/
175 /* nFreeRegs - returns number of free registers */
176 /*-----------------------------------------------------------------*/
183 for (i = 0; i < ds390_nRegs; i++)
184 if (regs390[i].isFree && regs390[i].type == type)
189 /*-----------------------------------------------------------------*/
190 /* nfreeRegsType - free registers with type */
191 /*-----------------------------------------------------------------*/
193 nfreeRegsType (int type)
198 if ((nfr = nFreeRegs (type)) == 0)
199 return nFreeRegs (REG_GPR);
202 return nFreeRegs (type);
207 /*-----------------------------------------------------------------*/
208 /* isOperandInReg - returns true if operand is currently in regs */
209 /*-----------------------------------------------------------------*/
210 static int isOperandInReg(operand *op)
212 if (!IS_SYMOP(op)) return 0;
213 if (OP_SYMBOL(op)->ruonly) return 1;
214 if (OP_SYMBOL(op)->accuse) return 1;
215 if (OP_SYMBOL(op)->dptr) return 1;
216 return bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(op)->key);
219 /*-----------------------------------------------------------------*/
220 /* computeSpillable - given a point find the spillable live ranges */
221 /*-----------------------------------------------------------------*/
223 computeSpillable (iCode * ic)
227 /* spillable live ranges are those that are live at this
228 point . the following categories need to be subtracted
230 a) - those that are already spilt
231 b) - if being used by this one
232 c) - defined by this one */
234 spillable = bitVectCopy (ic->rlive);
236 bitVectCplAnd (spillable, _G.spiltSet); /* those already spilt */
238 bitVectCplAnd (spillable, ic->uses); /* used in this one */
239 bitVectUnSetBit (spillable, ic->defKey);
240 spillable = bitVectIntersect (spillable, _G.regAssigned);
245 /*-----------------------------------------------------------------*/
246 /* noSpilLoc - return true if a variable has no spil location */
247 /*-----------------------------------------------------------------*/
249 noSpilLoc (symbol * sym, eBBlock * ebp, iCode * ic)
251 return (sym->usl.spillLoc ? 0 : 1);
254 /*-----------------------------------------------------------------*/
255 /* hasSpilLoc - will return 1 if the symbol has spil location */
256 /*-----------------------------------------------------------------*/
258 hasSpilLoc (symbol * sym, eBBlock * ebp, iCode * ic)
260 return (sym->usl.spillLoc ? 1 : 0);
263 /*-----------------------------------------------------------------*/
264 /* directSpilLoc - will return 1 if the splilocation is in direct */
265 /*-----------------------------------------------------------------*/
267 directSpilLoc (symbol * sym, eBBlock * ebp, iCode * ic)
269 if (sym->usl.spillLoc &&
270 (IN_DIRSPACE (SPEC_OCLS (sym->usl.spillLoc->etype))))
276 /*-----------------------------------------------------------------*/
277 /* hasSpilLocnoUptr - will return 1 if the symbol has spil location */
278 /* but is not used as a pointer */
279 /*-----------------------------------------------------------------*/
281 hasSpilLocnoUptr (symbol * sym, eBBlock * ebp, iCode * ic)
283 return ((sym->usl.spillLoc && !sym->uptr) ? 1 : 0);
286 /*-----------------------------------------------------------------*/
287 /* rematable - will return 1 if the remat flag is set */
288 /*-----------------------------------------------------------------*/
290 rematable (symbol * sym, eBBlock * ebp, iCode * ic)
295 /*-----------------------------------------------------------------*/
296 /* notUsedInRemaining - not used or defined in remain of the block */
297 /*-----------------------------------------------------------------*/
299 notUsedInRemaining (symbol * sym, eBBlock * ebp, iCode * ic)
301 return ((usedInRemaining (operandFromSymbol (sym), ic) ? 0 : 1) &&
302 allDefsOutOfRange (sym->defs, ebp->fSeq, ebp->lSeq));
305 /*-----------------------------------------------------------------*/
306 /* allLRs - return true for all */
307 /*-----------------------------------------------------------------*/
309 allLRs (symbol * sym, eBBlock * ebp, iCode * ic)
314 /*-----------------------------------------------------------------*/
315 /* liveRangesWith - applies function to a given set of live range */
316 /*-----------------------------------------------------------------*/
318 liveRangesWith (bitVect * lrs, int (func) (symbol *, eBBlock *, iCode *),
319 eBBlock * ebp, iCode * ic)
324 if (!lrs || !lrs->size)
327 for (i = 1; i < lrs->size; i++)
330 if (!bitVectBitValue (lrs, i))
333 /* if we don't find it in the live range
334 hash table we are in serious trouble */
335 if (!(sym = hTabItemWithKey (liveRanges, i)))
337 werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
338 "liveRangesWith could not find liveRange");
342 if (func (sym, ebp, ic) && bitVectBitValue (_G.regAssigned, sym->key))
343 addSetHead (&rset, sym);
350 /*-----------------------------------------------------------------*/
351 /* leastUsedLR - given a set determines which is the least used */
352 /*-----------------------------------------------------------------*/
354 leastUsedLR (set * sset)
356 symbol *sym = NULL, *lsym = NULL;
358 sym = lsym = setFirstItem (sset);
363 for (; lsym; lsym = setNextItem (sset))
366 /* if usage is the same then prefer
367 the spill the smaller of the two */
368 if (lsym->used == sym->used)
369 if (getSize (lsym->type) < getSize (sym->type))
373 if (lsym->used < sym->used)
378 setToNull ((void *) &sset);
383 /*-----------------------------------------------------------------*/
384 /* noOverLap - will iterate through the list looking for over lap */
385 /*-----------------------------------------------------------------*/
387 noOverLap (set * itmpStack, symbol * fsym)
391 for (sym = setFirstItem (itmpStack); sym;
392 sym = setNextItem (itmpStack))
394 if (bitVectBitValue(sym->clashes,fsym->key)) return 0;
399 /*-----------------------------------------------------------------*/
400 /* isFree - will return 1 if the a free spil location is found */
401 /*-----------------------------------------------------------------*/
406 V_ARG (symbol **, sloc);
407 V_ARG (symbol *, fsym);
409 /* if already found */
413 /* if it is free && and the itmp assigned to
414 this does not have any overlapping live ranges
415 with the one currently being assigned and
416 the size can be accomodated */
418 noOverLap (sym->usl.itmpStack, fsym) &&
419 getSize (sym->type) >= getSize (fsym->type))
428 /*-----------------------------------------------------------------*/
429 /* spillLRWithPtrReg :- will spil those live ranges which use PTR */
430 /*-----------------------------------------------------------------*/
432 spillLRWithPtrReg (symbol * forSym)
438 if (!_G.regAssigned ||
439 bitVectIsZero (_G.regAssigned))
442 r0 = ds390_regWithIdx (R0_IDX);
443 r1 = ds390_regWithIdx (R1_IDX);
445 /* for all live ranges */
446 for (lrsym = hTabFirstItem (liveRanges, &k); lrsym;
447 lrsym = hTabNextItem (liveRanges, &k))
451 /* if no registers assigned to it or spilt */
452 /* if it does not overlap this then
453 no need to spill it */
455 if (lrsym->isspilt || !lrsym->nRegs ||
456 (lrsym->liveTo < forSym->liveFrom))
459 /* go thru the registers : if it is either
460 r0 or r1 then spill it */
461 for (j = 0; j < lrsym->nRegs; j++)
462 if (lrsym->regs[j] == r0 ||
463 lrsym->regs[j] == r1)
472 /*-----------------------------------------------------------------*/
473 /* createStackSpil - create a location on the stack to spil */
474 /*-----------------------------------------------------------------*/
476 createStackSpil (symbol * sym)
479 int useXstack, model, noOverlay;
483 /* first go try and find a free one that is already
484 existing on the stack */
485 if (applyToSet (_G.stackSpil, isFree, &sloc, sym))
487 /* found a free one : just update & return */
488 sym->usl.spillLoc = sloc;
491 addSetHead (&sloc->usl.itmpStack, sym);
495 /* could not then have to create one , this is the hard part
496 we need to allocate this on the stack : this is really a
497 hack!! but cannot think of anything better at this time */
499 if (SNPRINTF (slocBuffer, sizeof(slocBuffer),
500 "sloc%d", _G.slocNum++) >= sizeof (slocBuffer))
502 fprintf (stderr, "***Internal error: slocBuffer overflowed: %s:%d\n",
507 sloc = newiTemp (slocBuffer);
509 /* set the type to the spilling symbol */
510 sloc->type = copyLinkChain (sym->type);
511 sloc->etype = getSpec (sloc->type);
512 if (options.model == MODEL_SMALL) {
513 SPEC_SCLS (sloc->etype) = S_DATA;
515 SPEC_SCLS (sloc->etype) = S_XDATA;
517 SPEC_EXTR (sloc->etype) = 0;
518 SPEC_STAT (sloc->etype) = 0;
519 SPEC_VOLATILE(sloc->etype) = 0;
520 SPEC_ABSA(sloc->etype) = 0;
522 /* we don't allow it to be allocated`
523 onto the external stack since : so we
524 temporarily turn it off ; we also
525 turn off memory model to prevent
526 the spil from going to the external storage
527 and turn off overlaying
530 useXstack = options.useXstack;
531 model = options.model;
532 noOverlay = options.noOverlay;
533 options.noOverlay = 1;
535 /* options.model = options.useXstack = 0; */
539 options.useXstack = useXstack;
540 options.model = model;
541 options.noOverlay = noOverlay;
542 sloc->isref = 1; /* to prevent compiler warning */
544 /* if it is on the stack then update the stack */
545 if (IN_STACK (sloc->etype))
547 currFunc->stack += getSize (sloc->type);
548 _G.stackExtend += getSize (sloc->type);
551 _G.dataExtend += getSize (sloc->type);
553 /* add it to the _G.stackSpil set */
554 addSetHead (&_G.stackSpil, sloc);
555 sym->usl.spillLoc = sloc;
558 /* add it to the set of itempStack set
559 of the spill location */
560 addSetHead (&sloc->usl.itmpStack, sym);
564 /*-----------------------------------------------------------------*/
565 /* isSpiltOnStack - returns true if the spil location is on stack */
566 /*-----------------------------------------------------------------*/
568 isSpiltOnStack (symbol * sym)
578 /* if (sym->_G.stackSpil) */
581 if (!sym->usl.spillLoc)
584 etype = getSpec (sym->usl.spillLoc->type);
585 if (IN_STACK (etype))
591 /*-----------------------------------------------------------------*/
592 /* spillThis - spils a specific operand */
593 /*-----------------------------------------------------------------*/
595 spillThis (symbol * sym)
598 /* if this is rematerializable or has a spillLocation
599 we are okay, else we need to create a spillLocation
601 if (!(sym->remat || sym->usl.spillLoc))
602 createStackSpil (sym);
604 /* mark it has spilt & put it in the spilt set */
605 sym->isspilt = sym->spillA = 1;
606 _G.spiltSet = bitVectSetBit (_G.spiltSet, sym->key);
608 bitVectUnSetBit (_G.regAssigned, sym->key);
609 bitVectUnSetBit (_G.totRegAssigned, sym->key);
611 for (i = 0; i < sym->nRegs; i++)
615 freeReg (sym->regs[i]);
619 /* if spilt on stack then free up r0 & r1
620 if they could have been assigned to some
622 if (!ds390_ptrRegReq && isSpiltOnStack (sym) && !options.stack10bit)
625 spillLRWithPtrReg (sym);
628 if (sym->usl.spillLoc && !sym->remat)
629 sym->usl.spillLoc->allocreq++;
633 /*-----------------------------------------------------------------*/
634 /* selectSpil - select a iTemp to spil : rather a simple procedure */
635 /*-----------------------------------------------------------------*/
637 selectSpil (iCode * ic, eBBlock * ebp, symbol * forSym)
639 bitVect *lrcs = NULL;
643 /* get the spillable live ranges */
644 lrcs = computeSpillable (ic);
646 /* get all live ranges that are rematerizable */
647 if ((selectS = liveRangesWith (lrcs, rematable, ebp, ic)))
650 /* return the least used of these */
651 return leastUsedLR (selectS);
654 /* get live ranges with spillLocations in direct space */
655 if ((selectS = liveRangesWith (lrcs, directSpilLoc, ebp, ic)))
657 sym = leastUsedLR (selectS);
658 strncpyz (sym->rname,
659 sym->usl.spillLoc->rname[0] ?
660 sym->usl.spillLoc->rname : sym->usl.spillLoc->name,
663 /* mark it as allocation required */
664 sym->usl.spillLoc->allocreq++;
668 /* if the symbol is local to the block then */
669 if (forSym->liveTo < ebp->lSeq)
672 /* check if there are any live ranges allocated
673 to registers that are not used in this block */
674 if (!_G.blockSpil && (selectS = liveRangesWith (lrcs, notUsedInBlock, ebp, ic)))
676 sym = leastUsedLR (selectS);
677 /* if this is not rematerializable */
686 /* check if there are any live ranges that not
687 used in the remainder of the block */
689 !isiCodeInFunctionCall (ic) &&
690 (selectS = liveRangesWith (lrcs, notUsedInRemaining, ebp, ic)))
692 sym = leastUsedLR (selectS);
705 /* find live ranges with spillocation && not used as pointers */
706 if ((selectS = liveRangesWith (lrcs, hasSpilLocnoUptr, ebp, ic)))
709 sym = leastUsedLR (selectS);
710 /* mark this as allocation required */
711 sym->usl.spillLoc->allocreq++;
715 /* find live ranges with spillocation */
716 if ((selectS = liveRangesWith (lrcs, hasSpilLoc, ebp, ic)))
719 sym = leastUsedLR (selectS);
720 sym->usl.spillLoc->allocreq++;
724 /* couldn't find then we need to create a spil
725 location on the stack , for which one? the least
727 if ((selectS = liveRangesWith (lrcs, noSpilLoc, ebp, ic)))
730 /* return a created spil location */
731 sym = createStackSpil (leastUsedLR (selectS));
732 sym->usl.spillLoc->allocreq++;
736 /* this is an extreme situation we will spill
737 this one : happens very rarely but it does happen */
743 /*-----------------------------------------------------------------*/
744 /* spilSomething - spil some variable & mark registers as free */
745 /*-----------------------------------------------------------------*/
747 spilSomething (iCode * ic, eBBlock * ebp, symbol * forSym)
752 /* get something we can spil */
753 ssym = selectSpil (ic, ebp, forSym);
755 /* mark it as spilt */
756 ssym->isspilt = ssym->spillA = 1;
757 _G.spiltSet = bitVectSetBit (_G.spiltSet, ssym->key);
759 /* mark it as not register assigned &
760 take it away from the set */
761 bitVectUnSetBit (_G.regAssigned, ssym->key);
762 bitVectUnSetBit (_G.totRegAssigned, ssym->key);
764 /* mark the registers as free */
765 for (i = 0; i < ssym->nRegs; i++)
767 freeReg (ssym->regs[i]);
769 /* if spilt on stack then free up r0 & r1
770 if they could have been assigned to as gprs */
771 if (!ds390_ptrRegReq && isSpiltOnStack (ssym) && !options.stack10bit)
774 spillLRWithPtrReg (ssym);
777 /* if this was a block level spil then insert push & pop
778 at the start & end of block respectively */
781 iCode *nic = newiCode (IPUSH, operandFromSymbol (ssym), NULL);
782 /* add push to the start of the block */
783 addiCodeToeBBlock (ebp, nic, (ebp->sch->op == LABEL ?
784 ebp->sch->next : ebp->sch));
785 nic = newiCode (IPOP, operandFromSymbol (ssym), NULL);
786 /* add pop to the end of the block */
787 addiCodeToeBBlock (ebp, nic, NULL);
790 /* if spilt because not used in the remainder of the
791 block then add a push before this instruction and
792 a pop at the end of the block */
793 if (ssym->remainSpil)
796 iCode *nic = newiCode (IPUSH, operandFromSymbol (ssym), NULL);
797 /* add push just before this instruction */
798 addiCodeToeBBlock (ebp, nic, ic);
800 nic = newiCode (IPOP, operandFromSymbol (ssym), NULL);
801 /* add pop to the end of the block */
802 addiCodeToeBBlock (ebp, nic, NULL);
811 /*-----------------------------------------------------------------*/
812 /* getRegPtr - will try for PTR if not a GPR type if not spil */
813 /*-----------------------------------------------------------------*/
815 getRegPtr (iCode * ic, eBBlock * ebp, symbol * sym)
821 /* try for a ptr type */
822 if ((reg = allocReg (REG_PTR)))
825 /* try for gpr type */
826 if ((reg = allocReg (REG_GPR)))
829 /* we have to spil */
830 if (!spilSomething (ic, ebp, sym))
833 /* make sure partially assigned registers aren't reused */
834 for (j=0; j<=sym->nRegs; j++)
836 sym->regs[j]->isFree = 0;
838 /* this looks like an infinite loop but
839 in really selectSpil will abort */
843 /*-----------------------------------------------------------------*/
844 /* getRegGpr - will try for GPR if not spil */
845 /*-----------------------------------------------------------------*/
847 getRegGpr (iCode * ic, eBBlock * ebp, symbol * sym)
853 /* try for gpr type */
854 if ((reg = allocReg (REG_GPR)))
857 if (!ds390_ptrRegReq)
858 if ((reg = allocReg (REG_PTR)))
861 /* we have to spil */
862 if (!spilSomething (ic, ebp, sym))
865 /* make sure partially assigned registers aren't reused */
866 for (j=0; j<=sym->nRegs; j++)
868 sym->regs[j]->isFree = 0;
870 /* this looks like an infinite loop but
871 in really selectSpil will abort */
875 /*-----------------------------------------------------------------*/
876 /* getRegPtrNoSpil - get it cannot split */
877 /*-----------------------------------------------------------------*/
878 static regs *getRegPtrNoSpil()
882 /* try for a ptr type */
883 if ((reg = allocReg (REG_PTR)))
886 /* try for gpr type */
887 if ((reg = allocReg (REG_GPR)))
892 /* just to make the compiler happy */
896 /*-----------------------------------------------------------------*/
897 /* getRegGprNoSpil - get it cannot split */
898 /*-----------------------------------------------------------------*/
899 static regs *getRegGprNoSpil()
903 if ((reg = allocReg (REG_GPR)))
906 if (!ds390_ptrRegReq)
907 if ((reg = allocReg (REG_PTR)))
912 /* just to make the compiler happy */
916 /*-----------------------------------------------------------------*/
917 /* symHasReg - symbol has a given register */
918 /*-----------------------------------------------------------------*/
920 symHasReg (symbol * sym, regs * reg)
924 for (i = 0; i < sym->nRegs; i++)
925 if (sym->regs[i] == reg)
931 /*-----------------------------------------------------------------*/
932 /* deassignLRs - check the live to and if they have registers & are */
933 /* not spilt then free up the registers */
934 /*-----------------------------------------------------------------*/
936 deassignLRs (iCode * ic, eBBlock * ebp)
942 for (sym = hTabFirstItem (liveRanges, &k); sym;
943 sym = hTabNextItem (liveRanges, &k))
947 /* if it does not end here */
948 if (sym->liveTo > ic->seq)
951 /* if it was spilt on stack then we can
952 mark the stack spil location as free */
957 sym->usl.spillLoc->isFree = 1;
963 if (!bitVectBitValue (_G.regAssigned, sym->key))
966 /* special case check if this is an IFX &
967 the privious one was a pop and the
968 previous one was not spilt then keep track
970 if (ic->op == IFX && ic->prev &&
971 ic->prev->op == IPOP &&
972 !ic->prev->parmPush &&
973 !OP_SYMBOL (IC_LEFT (ic->prev))->isspilt)
974 psym = OP_SYMBOL (IC_LEFT (ic->prev));
980 bitVectUnSetBit (_G.regAssigned, sym->key);
982 /* if the result of this one needs registers
983 and does not have it then assign it right
985 if (IC_RESULT (ic) &&
986 !(SKIP_IC2 (ic) || /* not a special icode */
987 ic->op == JUMPTABLE ||
993 (result = OP_SYMBOL (IC_RESULT (ic))) && /* has a result */
994 result->liveTo > ic->seq && /* and will live beyond this */
995 result->liveTo <= ebp->lSeq && /* does not go beyond this block */
996 result->liveFrom == ic->seq && /* does not start before here */
997 result->regType == sym->regType && /* same register types */
998 result->nRegs && /* which needs registers */
999 !result->isspilt && /* and does not already have them */
1001 !bitVectBitValue (_G.regAssigned, result->key) &&
1002 /* the number of free regs + number of regs in this LR
1003 can accomodate the what result Needs */
1004 ((nfreeRegsType (result->regType) +
1005 sym->nRegs) >= result->nRegs)
1009 for (i = 0; i < result->nRegs; i++)
1011 result->regs[i] = sym->regs[i];
1013 result->regs[i] = getRegGpr (ic, ebp, result);
1015 _G.regAssigned = bitVectSetBit (_G.regAssigned, result->key);
1016 _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, result->key);
1020 /* free the remaining */
1021 for (; i < sym->nRegs; i++)
1025 if (!symHasReg (psym, sym->regs[i]))
1026 freeReg (sym->regs[i]);
1029 freeReg (sym->regs[i]);
1036 /*-----------------------------------------------------------------*/
1037 /* reassignLR - reassign this to registers */
1038 /*-----------------------------------------------------------------*/
1040 reassignLR (operand * op)
1042 symbol *sym = OP_SYMBOL (op);
1045 /* not spilt any more */
1046 sym->isspilt = sym->spillA = sym->blockSpil = sym->remainSpil = 0;
1047 bitVectUnSetBit (_G.spiltSet, sym->key);
1049 _G.regAssigned = bitVectSetBit (_G.regAssigned, sym->key);
1050 _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, sym->key);
1054 for (i = 0; i < sym->nRegs; i++)
1055 sym->regs[i]->isFree = 0;
1058 /*-----------------------------------------------------------------*/
1059 /* willCauseSpill - determines if allocating will cause a spill */
1060 /*-----------------------------------------------------------------*/
1062 willCauseSpill (int nr, int rt)
1064 /* first check if there are any avlb registers
1065 of te type required */
1068 /* special case for pointer type
1069 if pointer type not avlb then
1070 check for type gpr */
1071 if (nFreeRegs (rt) >= nr)
1073 if (nFreeRegs (REG_GPR) >= nr)
1078 if (ds390_ptrRegReq)
1080 if (nFreeRegs (rt) >= nr)
1085 if (nFreeRegs (REG_PTR) +
1086 nFreeRegs (REG_GPR) >= nr)
1091 /* it will cause a spil */
1095 /*-----------------------------------------------------------------*/
1096 /* positionRegs - the allocator can allocate same registers to res- */
1097 /* ult and operand, if this happens make sure they are in the same */
1098 /* position as the operand otherwise chaos results */
1099 /*-----------------------------------------------------------------*/
1101 positionRegs (symbol * result, symbol * opsym)
1103 int count = min (result->nRegs, opsym->nRegs);
1104 int i, j = 0, shared = 0;
1107 /* if the result has been spilt then cannot share */
1112 /* first make sure that they actually share */
1113 for (i = 0; i < count; i++)
1115 for (j = 0; j < count; j++)
1117 if (result->regs[i] == opsym->regs[j] && i != j)
1127 regs *tmp = result->regs[i];
1128 result->regs[i] = result->regs[j];
1129 result->regs[j] = tmp;
1136 /*-----------------------------------------------------------------*/
1137 /* unusedLRS - returns a bitVector of liveranges not used in 'ebp' */
1138 /*-----------------------------------------------------------------*/
1139 bitVect *unusedLRs (eBBlock *ebp)
1141 bitVect *ret = NULL;
1145 if (!ebp) return NULL;
1146 for (sym = hTabFirstItem(liveRanges,&key); sym ;
1147 sym = hTabNextItem(liveRanges,&key)) {
1149 if (notUsedInBlock(sym,ebp,NULL)) {
1150 ret = bitVectSetBit(ret,sym->key);
1157 /*-----------------------------------------------------------------*/
1158 /* deassignUnsedLRs - if this baisc block ends in a return then */
1159 /* deassign symbols not used in this block */
1160 /*-----------------------------------------------------------------*/
1161 bitVect *deassignUnsedLRs(eBBlock *ebp)
1163 bitVect *unused = NULL;
1166 switch (returnAtEnd(ebp)) {
1167 case 2: /* successor block ends in a return */
1168 unused = unusedLRs((eBBlock *) setFirstItem(ebp->succList));
1170 case 1: /* this block ends in a return */
1171 unused = bitVectIntersect(unused,unusedLRs(ebp));
1176 for (i = 0 ; i < unused->size ; i++ ) {
1179 if (bitVectBitValue(unused,i)) {
1181 /* if assigned to registers */
1182 if (bitVectBitValue(_G.regAssigned,i)) {
1186 sym = hTabItemWithKey(liveRanges,i);
1187 /* remove it from regassigned & mark the
1189 bitVectUnSetBit(_G.regAssigned,i);
1190 for (j = 0 ; j < sym->nRegs; j++)
1191 freeReg(sym->regs[j]);
1193 /* not assigned to registers : remove from set*/
1194 bitVectUnSetBit(unused,i);
1202 /*-----------------------------------------------------------------*/
1203 /* reassignUnusedLRs - put registers to unused Live ranges */
1204 /*-----------------------------------------------------------------*/
1205 void reassignUnusedLRs (bitVect *unused)
1208 if (!unused) return ;
1210 for (i = 0 ; i < unused->size ; i++ ) {
1211 /* if unused : means it was assigned to registers before */
1212 if (bitVectBitValue(unused,i)) {
1216 /* put it back into reg set*/
1217 bitVectSetBit(_G.regAssigned,i) ;
1219 sym = hTabItemWithKey(liveRanges,i);
1220 /* makr registers busy */
1221 for (j = 0 ; j < sym->nRegs; j++)
1222 sym->regs[j]->isFree = 0;
1227 /*------------------------------------------------------------------*/
1228 /* verifyRegsAssigned - make sure an iTemp is properly initialized; */
1229 /* it should either have registers or have beed spilled. Otherwise, */
1230 /* there was an uninitialized variable, so just spill this to get */
1231 /* the operand in a valid state. */
1232 /*------------------------------------------------------------------*/
1234 verifyRegsAssigned (operand *op, iCode * ic)
1239 if (!IS_ITEMP (op)) return;
1241 sym = OP_SYMBOL (op);
1242 if (sym->isspilt) return;
1243 if (!sym->nRegs) return;
1244 if (sym->regs[0]) return;
1246 werrorfl (ic->filename, ic->lineno, W_LOCAL_NOINIT,
1247 sym->prereqv ? sym->prereqv->name : sym->name);
1252 /*-----------------------------------------------------------------*/
1253 /* serialRegAssign - serially allocate registers to the variables */
1254 /*-----------------------------------------------------------------*/
1256 serialRegAssign (eBBlock ** ebbs, int count)
1260 /* for all blocks */
1261 for (i = 0; i < count; i++)
1265 bitVect *unusedLRs = NULL;
1267 if (ebbs[i]->noPath &&
1268 (ebbs[i]->entryLabel != entryLabel &&
1269 ebbs[i]->entryLabel != returnLabel))
1272 unusedLRs = deassignUnsedLRs(ebbs[i]);
1274 /* for all instructions do */
1275 for (ic = ebbs[i]->sch; ic; ic = ic->next)
1278 /* if this is an ipop that means some live
1279 range will have to be assigned again */
1281 reassignLR (IC_LEFT (ic));
1283 /* if result is present && is a true symbol */
1284 if (IC_RESULT (ic) && ic->op != IFX &&
1285 IS_TRUE_SYMOP (IC_RESULT (ic)))
1286 OP_SYMBOL (IC_RESULT (ic))->allocreq++;
1288 /* take away registers from live
1289 ranges that end at this instruction */
1290 deassignLRs (ic, ebbs[i]);
1292 /* some don't need registers */
1293 if (SKIP_IC2 (ic) ||
1294 ic->op == JUMPTABLE ||
1298 (IC_RESULT (ic) && POINTER_SET (ic)))
1301 /* now we need to allocate registers
1302 only for the result */
1305 symbol *sym = OP_SYMBOL (IC_RESULT (ic));
1311 /* Make sure any spill location is definately allocated */
1312 if (sym->isspilt && !sym->remat && sym->usl.spillLoc &&
1313 !sym->usl.spillLoc->allocreq)
1315 sym->usl.spillLoc->allocreq++;
1318 /* if it does not need or is spilt
1319 or is already assigned to registers
1320 or will not live beyond this instructions */
1323 bitVectBitValue (_G.regAssigned, sym->key) ||
1324 sym->liveTo <= ic->seq)
1327 /* if some liverange has been spilt at the block level
1328 and this one live beyond this block then spil this
1330 if (_G.blockSpil && sym->liveTo > ebbs[i]->lSeq)
1336 /* if this is a bit variable then don't use precious registers
1337 along with expensive bit-to-char conversions but just spill
1339 if (SPEC_NOUN(sym->etype) == V_BIT)
1345 /* if trying to allocate this will cause
1346 a spill and there is nothing to spill
1347 or this one is rematerializable then
1349 willCS = willCauseSpill (sym->nRegs, sym->regType);
1350 spillable = computeSpillable (ic);
1352 (willCS && bitVectIsZero (spillable)))
1360 /* If the live range preceeds the point of definition
1361 then ideally we must take into account registers that
1362 have been allocated after sym->liveFrom but freed
1363 before ic->seq. This is complicated, so spill this
1364 symbol instead and let fillGaps handle the allocation. */
1365 if (sym->liveFrom < ic->seq)
1371 /* if it has a spillocation & is used less than
1372 all other live ranges then spill this */
1374 if (sym->usl.spillLoc) {
1375 symbol *leastUsed = leastUsedLR (liveRangesWith (spillable,
1376 allLRs, ebbs[i], ic));
1377 if (leastUsed && leastUsed->used > sym->used) {
1382 /* if none of the liveRanges have a spillLocation then better
1383 to spill this one than anything else already assigned to registers */
1384 if (liveRangesWith(spillable,noSpilLoc,ebbs[i],ic)) {
1385 /* if this is local to this block then we might find a block spil */
1386 if (!(sym->liveFrom >= ebbs[i]->fSeq && sym->liveTo <= ebbs[i]->lSeq)) {
1394 /* if we need ptr regs for the right side
1396 if (POINTER_GET (ic) && IS_SYMOP (IC_LEFT (ic))
1397 && getSize (OP_SYMBOL (IC_LEFT (ic))->type)
1398 <= (unsigned) PTRSIZE)
1403 /* else we assign registers to it */
1404 _G.regAssigned = bitVectSetBit (_G.regAssigned, sym->key);
1405 _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, sym->key);
1407 for (j = 0; j < sym->nRegs; j++)
1409 if (sym->regType == REG_PTR)
1410 sym->regs[j] = getRegPtr (ic, ebbs[i], sym);
1412 sym->regs[j] = getRegGpr (ic, ebbs[i], sym);
1414 /* if the allocation falied which means
1415 this was spilt then break */
1420 /* if it shares registers with operands make sure
1421 that they are in the same position */
1422 if (!POINTER_SET(ic) && !POINTER_GET(ic))
1424 if (IC_LEFT (ic) && IS_SYMOP (IC_LEFT (ic)) &&
1425 OP_SYMBOL (IC_LEFT (ic))->nRegs)
1427 positionRegs (OP_SYMBOL (IC_RESULT (ic)),
1428 OP_SYMBOL (IC_LEFT (ic)));
1430 /* do the same for the right operand */
1431 if (IC_RIGHT (ic) && IS_SYMOP (IC_RIGHT (ic)) &&
1432 OP_SYMBOL (IC_RIGHT (ic))->nRegs)
1434 positionRegs (OP_SYMBOL (IC_RESULT (ic)),
1435 OP_SYMBOL (IC_RIGHT (ic)));
1447 reassignUnusedLRs(unusedLRs);
1450 /* Check for and fix any problems with uninitialized operands */
1451 for (i = 0; i < count; i++)
1455 if (ebbs[i]->noPath &&
1456 (ebbs[i]->entryLabel != entryLabel &&
1457 ebbs[i]->entryLabel != returnLabel))
1460 for (ic = ebbs[i]->sch; ic; ic = ic->next)
1467 verifyRegsAssigned (IC_COND (ic), ic);
1471 if (ic->op == JUMPTABLE)
1473 verifyRegsAssigned (IC_JTCOND (ic), ic);
1477 verifyRegsAssigned (IC_RESULT (ic), ic);
1478 verifyRegsAssigned (IC_LEFT (ic), ic);
1479 verifyRegsAssigned (IC_RIGHT (ic), ic);
1484 /*-----------------------------------------------------------------*/
1485 /* fillGaps - Try to fill in the Gaps left by Pass1 */
1486 /*-----------------------------------------------------------------*/
1487 static void fillGaps()
1491 int loop = 0, change;
1494 if (getenv("DISABLE_FILL_GAPS")) return;
1496 /* First try to do DPTRuse once more since now we know what got into
1499 while (loop++ < 10) {
1502 for (sym = hTabFirstItem(liveRanges,&key) ; sym ;
1503 sym = hTabNextItem(liveRanges,&key)) {
1504 int size = getSize(sym->type);
1506 if (sym->liveFrom == sym->liveTo) continue;
1508 if (sym->uptr && sym->dptr==0 && !sym->ruonly &&
1509 size < 4 && size > 1) {
1511 if (packRegsDPTRuse(operandFromSymbol(sym))) {
1513 /* if this was assigned to registers then */
1514 if (bitVectBitValue(_G.totRegAssigned,sym->key)) {
1515 /* take it out of the register assigned set */
1516 bitVectUnSetBit(_G.totRegAssigned,sym->key);
1517 } else if (sym->usl.spillLoc) {
1518 sym->usl.spillLoc->allocreq--;
1519 sym->usl.spillLoc = NULL;
1523 sym->isspilt = sym->spillA = 0;
1527 /* try assigning other dptrs */
1528 if (sym->dptr == 0 && packRegsDPTRnuse(operandFromSymbol(sym),1) && !getenv("DPTRnDISABLE")) {
1529 /* if this was ssigned to registers then */
1530 if (bitVectBitValue(_G.totRegAssigned,sym->key)) {
1531 /* take it out of the register assigned set */
1532 bitVectUnSetBit(_G.totRegAssigned,sym->key);
1533 } else if (sym->usl.spillLoc) {
1534 sym->usl.spillLoc->allocreq--;
1535 sym->usl.spillLoc = NULL;
1538 sym->isspilt = sym->spillA = 0;
1543 /* look for livernages that was spilt by the allocator */
1544 for (sym = hTabFirstItem(liveRanges,&key) ; sym ;
1545 sym = hTabNextItem(liveRanges,&key)) {
1550 if (!sym->spillA || !sym->clashes || sym->remat) continue ;
1551 if (!sym->uses || !sym->defs) continue ;
1552 /* find the liveRanges this one clashes with, that are
1553 still assigned to registers & mark the registers as used*/
1554 for ( i = 0 ; i < sym->clashes->size ; i ++) {
1558 if (bitVectBitValue(sym->clashes,i) == 0 || /* those that clash with this */
1559 bitVectBitValue(_G.totRegAssigned,i) == 0) /* and are still assigned to registers */
1562 clr = hTabItemWithKey(liveRanges,i);
1565 /* mark these registers as used */
1566 for (k = 0 ; k < clr->nRegs ; k++ )
1567 useReg(clr->regs[k]);
1570 if (willCauseSpill(sym->nRegs,sym->regType)) {
1571 /* NOPE :( clear all registers & and continue */
1576 /* THERE IS HOPE !!!! */
1577 for (i=0; i < sym->nRegs ; i++ ) {
1578 if (sym->regType == REG_PTR)
1579 sym->regs[i] = getRegPtrNoSpil ();
1581 sym->regs[i] = getRegGprNoSpil ();
1584 /* For all its definitions check if the registers
1585 allocated needs positioning NOTE: we can position
1586 only ONCE if more than One positioning required
1588 We may need to perform the checks twice; once to
1589 position the registers as needed, the second to
1590 verify any register repositioning is still
1594 for (pass=0; pass<2; pass++) {
1595 for (i = 0 ; i < sym->defs->size ; i++ ) {
1596 if (bitVectBitValue(sym->defs,i)) {
1598 if (!(ic = hTabItemWithKey(iCodehTab,i))) continue ;
1599 if (SKIP_IC(ic)) continue;
1600 assert(isSymbolEqual(sym,OP_SYMBOL(IC_RESULT(ic)))); /* just making sure */
1601 /* if left is assigned to registers */
1602 if (IS_SYMOP(IC_LEFT(ic)) &&
1603 bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_LEFT(ic))->key)) {
1604 pdone += (positionRegs(sym,OP_SYMBOL(IC_LEFT(ic)))>0);
1606 if (IS_SYMOP(IC_RIGHT(ic)) &&
1607 bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_RIGHT(ic))->key)) {
1608 pdone += (positionRegs(sym,OP_SYMBOL(IC_RIGHT(ic)))>0);
1610 if (pdone > 1) break;
1613 for (i = 0 ; i < sym->uses->size ; i++ ) {
1614 if (bitVectBitValue(sym->uses,i)) {
1616 if (!(ic = hTabItemWithKey(iCodehTab,i))) continue ;
1617 if (SKIP_IC(ic)) continue;
1618 if (POINTER_SET(ic) || POINTER_GET(ic)) continue ;
1620 /* if result is assigned to registers */
1621 if (IS_SYMOP(IC_RESULT(ic)) &&
1622 bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_RESULT(ic))->key)) {
1623 pdone += (positionRegs(sym,OP_SYMBOL(IC_RESULT(ic)))>0);
1625 if (pdone > 1) break;
1628 if (pdone == 0) break; /* second pass only if regs repositioned */
1629 if (pdone > 1) break;
1631 /* had to position more than once GIVE UP */
1633 /* UNDO all the changes we made to try this */
1635 for (i=0; i < sym->nRegs ; i++ ) {
1636 sym->regs[i] = NULL;
1639 D (fprintf (stderr, "Fill Gap gave up due to positioning for "
1640 "%s in function %s\n",
1641 sym->name, currFunc ? currFunc->name : "UNKNOWN"));
1644 D (fprintf (stderr, "FILLED GAP for %s in function %s\n",
1645 sym->name, currFunc ? currFunc->name : "UNKNOWN"));
1646 _G.totRegAssigned = bitVectSetBit(_G.totRegAssigned,sym->key);
1647 sym->isspilt = sym->spillA = 0 ;
1648 sym->usl.spillLoc->allocreq--;
1649 sym->usl.spillLoc = NULL;
1657 /*-----------------------------------------------------------------*/
1658 /* rUmaskForOp :- returns register mask for an operand */
1659 /*-----------------------------------------------------------------*/
1661 ds390_rUmaskForOp (operand * op)
1667 /* only temporaries are assigned registers */
1671 sym = OP_SYMBOL (op);
1673 /* if spilt or no registers assigned to it
1675 if (sym->isspilt || !sym->nRegs)
1678 rumask = newBitVect (ds390_nRegs);
1680 for (j = 0; j < sym->nRegs; j++)
1682 rumask = bitVectSetBit (rumask,
1683 sym->regs[j]->rIdx);
1689 /*-----------------------------------------------------------------*/
1690 /* regsUsedIniCode :- returns bit vector of registers used in iCode */
1691 /*-----------------------------------------------------------------*/
1693 regsUsedIniCode (iCode * ic)
1695 bitVect *rmask = newBitVect (ds390_nRegs);
1697 /* do the special cases first */
1700 rmask = bitVectUnion (rmask,
1701 ds390_rUmaskForOp (IC_COND (ic)));
1705 /* for the jumptable */
1706 if (ic->op == JUMPTABLE)
1708 rmask = bitVectUnion (rmask,
1709 ds390_rUmaskForOp (IC_JTCOND (ic)));
1714 /* of all other cases */
1716 rmask = bitVectUnion (rmask,
1717 ds390_rUmaskForOp (IC_LEFT (ic)));
1721 rmask = bitVectUnion (rmask,
1722 ds390_rUmaskForOp (IC_RIGHT (ic)));
1725 rmask = bitVectUnion (rmask,
1726 ds390_rUmaskForOp (IC_RESULT (ic)));
1732 /*-----------------------------------------------------------------*/
1733 /* createRegMask - for each instruction will determine the regsUsed */
1734 /*-----------------------------------------------------------------*/
1736 createRegMask (eBBlock ** ebbs, int count)
1740 /* for all blocks */
1741 for (i = 0; i < count; i++)
1745 if (ebbs[i]->noPath &&
1746 (ebbs[i]->entryLabel != entryLabel &&
1747 ebbs[i]->entryLabel != returnLabel))
1750 /* for all instructions */
1751 for (ic = ebbs[i]->sch; ic; ic = ic->next)
1756 if (SKIP_IC2 (ic) || !ic->rlive)
1759 /* first mark the registers used in this
1761 ic->rUsed = regsUsedIniCode (ic);
1762 _G.funcrUsed = bitVectUnion (_G.funcrUsed, ic->rUsed);
1764 /* now create the register mask for those
1765 registers that are in use : this is a
1766 super set of ic->rUsed */
1767 ic->rMask = newBitVect (ds390_nRegs + 1);
1769 /* for all live Ranges alive at this point */
1770 for (j = 1; j < ic->rlive->size; j++)
1775 /* if not alive then continue */
1776 if (!bitVectBitValue (ic->rlive, j))
1779 /* find the live range we are interested in */
1780 if (!(sym = hTabItemWithKey (liveRanges, j)))
1782 werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
1783 "createRegMask cannot find live range");
1784 fprintf(stderr, "\tmissing live range: key=%d\n", j);
1788 /* special case for ruonly */
1789 if (sym->ruonly && sym->liveFrom != sym->liveTo) {
1790 int size = getSize(sym->type);
1792 for (k = 0 ; k < size; k++ )
1793 ic->rMask = bitVectSetBit (ic->rMask, j++);
1797 /* if no register assigned to it */
1798 if (!sym->nRegs || sym->isspilt)
1801 /* for all the registers allocated to it */
1802 for (k = 0; k < sym->nRegs; k++)
1805 bitVectSetBit (ic->rMask, sym->regs[k]->rIdx);
1811 /*-----------------------------------------------------------------*/
1812 /* rematStr - returns the rematerialized string for a remat var */
1813 /*-----------------------------------------------------------------*/
1815 rematStr (symbol * sym)
1818 iCode *ic = sym->rematiCode;
1825 /* if plus or minus print the right hand side */
1826 if (ic->op == '+' || ic->op == '-')
1828 SNPRINTF (s, sizeof(buffer) - strlen(buffer),
1829 "0x%04x %c ", (int) operandLitValue (IC_RIGHT (ic)),
1832 ic = OP_SYMBOL (IC_LEFT (ic))->rematiCode;
1836 /* cast then continue */
1837 if (IS_CAST_ICODE(ic)) {
1838 ic = OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
1841 /* we reached the end */
1842 SNPRINTF (s, sizeof(buffer) - strlen(buffer),
1843 "%s", OP_SYMBOL (IC_LEFT (ic))->rname);
1850 /*-----------------------------------------------------------------*/
1851 /* regTypeNum - computes the type & number of registers required */
1852 /*-----------------------------------------------------------------*/
1860 /* for each live range do */
1861 for (sym = hTabFirstItem (liveRanges, &k); sym;
1862 sym = hTabNextItem (liveRanges, &k))
1865 /* if used zero times then no registers needed */
1866 if ((sym->liveTo - sym->liveFrom) == 0)
1870 /* if the live range is a temporary */
1874 /* if the type is marked as a conditional */
1875 if (sym->regType == REG_CND)
1878 /* if used in return only then we don't
1880 if (sym->ruonly || sym->accuse)
1882 if (IS_AGGREGATE (sym->type) || sym->isptr)
1883 sym->type = aggrToPtr (sym->type, FALSE);
1887 /* if the symbol has only one definition &
1888 that definition is a get_pointer */
1889 if (bitVectnBitsOn (sym->defs) == 1 &&
1890 (ic = hTabItemWithKey (iCodehTab,
1891 bitVectFirstBit (sym->defs))) &&
1893 !IS_BITVAR (sym->etype) &&
1894 (aggrToPtrDclType (operandType (IC_LEFT (ic)), FALSE) == POINTER))
1897 if (ptrPseudoSymSafe (sym, ic))
1899 ptrPseudoSymConvert (sym, ic, rematStr (OP_SYMBOL (IC_LEFT (ic))));
1903 /* if in data space or idata space then try to
1904 allocate pointer register */
1908 /* if not then we require registers */
1909 sym->nRegs = ((IS_AGGREGATE (sym->type) || sym->isptr) ?
1910 getSize (sym->type = aggrToPtr (sym->type, FALSE)) :
1911 getSize (sym->type));
1915 fprintf (stderr, "allocated more than 4 or 0 registers for type ");
1916 printTypeChain (sym->type, stderr);
1917 fprintf (stderr, "\n");
1920 /* determine the type of register required */
1921 if (sym->nRegs == 1 &&
1922 IS_PTR (sym->type) &&
1924 sym->regType = REG_PTR;
1926 sym->regType = REG_GPR;
1930 /* for the first run we don't provide */
1931 /* registers for true symbols we will */
1932 /* see how things go */
1938 /*-----------------------------------------------------------------*/
1939 /* freeAllRegs - mark all registers as free */
1940 /*-----------------------------------------------------------------*/
1946 for (i = 0; i < ds390_nRegs; i++)
1947 regs390[i].isFree = 1;
1950 /*-----------------------------------------------------------------*/
1951 /* deallocStackSpil - this will set the stack pointer back */
1952 /*-----------------------------------------------------------------*/
1954 DEFSETFUNC (deallocStackSpil)
1962 /*-----------------------------------------------------------------*/
1963 /* farSpacePackable - returns the packable icode for far variables */
1964 /*-----------------------------------------------------------------*/
1966 farSpacePackable (iCode * ic)
1970 /* go thru till we find a definition for the
1971 symbol on the right */
1972 for (dic = ic->prev; dic; dic = dic->prev)
1974 /* if the definition is a call then no */
1975 if ((dic->op == CALL || dic->op == PCALL) &&
1976 IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
1981 /* if shift by unknown amount then not */
1982 if ((dic->op == LEFT_OP || dic->op == RIGHT_OP) &&
1983 IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
1986 /* if pointer get and size > 1 */
1987 if (POINTER_GET (dic) &&
1988 getSize (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)) > 1)
1991 if (POINTER_SET (dic) &&
1992 getSize (aggrToPtr (operandType (IC_RESULT (dic)), FALSE)) > 1)
1995 /* if any tree is a true symbol in far space */
1996 if (IC_RESULT (dic) &&
1997 IS_TRUE_SYMOP (IC_RESULT (dic)) &&
1998 isOperandInFarSpace (IC_RESULT (dic)))
2001 if (IC_RIGHT (dic) &&
2002 IS_TRUE_SYMOP (IC_RIGHT (dic)) &&
2003 isOperandInFarSpace (IC_RIGHT (dic)) &&
2004 !isOperandEqual (IC_RIGHT (dic), IC_RESULT (ic)))
2007 if (IC_LEFT (dic) &&
2008 IS_TRUE_SYMOP (IC_LEFT (dic)) &&
2009 isOperandInFarSpace (IC_LEFT (dic)) &&
2010 !isOperandEqual (IC_LEFT (dic), IC_RESULT (ic)))
2013 if (isOperandEqual (IC_RIGHT (ic), IC_RESULT (dic)))
2015 if ((dic->op == LEFT_OP ||
2016 dic->op == RIGHT_OP ||
2018 IS_OP_LITERAL (IC_RIGHT (dic)))
2028 /*-----------------------------------------------------------------*/
2029 /* packRegsForAssign - register reduction for assignment */
2030 /*-----------------------------------------------------------------*/
2032 packRegsForAssign (iCode * ic, eBBlock * ebp)
2036 if (!IS_ITEMP (IC_RIGHT (ic)) ||
2037 OP_SYMBOL (IC_RIGHT (ic))->isind ||
2038 OP_LIVETO (IC_RIGHT (ic)) > ic->seq)
2043 /* if the true symbol is defined in far space or on stack
2044 then we should not since this will increase register pressure */
2046 if (isOperandInFarSpace (IC_RESULT (ic)))
2048 if ((dic = farSpacePackable (ic)))
2054 if (isOperandInFarSpace(IC_RESULT(ic)) && !farSpacePackable(ic)) {
2059 /* find the definition of iTempNN scanning backwards if we find a
2060 a use of the true symbol in before we find the definition then
2062 for (dic = ic->prev; dic; dic = dic->prev)
2064 /* if there is a function call then don't pack it */
2065 if ((dic->op == CALL || dic->op == PCALL))
2074 if (IS_TRUE_SYMOP (IC_RESULT (dic)) &&
2075 IS_OP_VOLATILE (IC_RESULT (dic)))
2081 if (IS_SYMOP (IC_RESULT (dic)) &&
2082 IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
2084 if (POINTER_SET (dic))
2090 if (IS_SYMOP (IC_RIGHT (dic)) &&
2091 (IC_RIGHT (dic)->key == IC_RESULT (ic)->key ||
2092 IC_RIGHT (dic)->key == IC_RIGHT (ic)->key))
2098 if (IS_SYMOP (IC_LEFT (dic)) &&
2099 (IC_LEFT (dic)->key == IC_RESULT (ic)->key ||
2100 IC_LEFT (dic)->key == IC_RIGHT (ic)->key))
2106 if (POINTER_SET (dic) &&
2107 IC_RESULT (dic)->key == IC_RESULT (ic)->key)
2115 return 0; /* did not find */
2117 /* if assignment then check that right is not a bit */
2118 if (ASSIGNMENT (ic) && !POINTER_SET (ic))
2120 sym_link *etype = operandType (IC_RESULT (dic));
2121 if (IS_BITFIELD (etype))
2123 /* if result is a bit too then it's ok */
2124 etype = operandType (IC_RESULT (ic));
2125 if (!IS_BITFIELD (etype))
2131 /* if the result is on stack or iaccess then it must be
2132 the same atleast one of the operands */
2133 if (OP_SYMBOL (IC_RESULT (ic))->onStack ||
2134 OP_SYMBOL (IC_RESULT (ic))->iaccess)
2137 /* the operation has only one symbol
2138 operator then we can pack */
2139 if ((IC_LEFT (dic) && !IS_SYMOP (IC_LEFT (dic))) ||
2140 (IC_RIGHT (dic) && !IS_SYMOP (IC_RIGHT (dic))))
2143 if (!((IC_LEFT (dic) &&
2144 IC_RESULT (ic)->key == IC_LEFT (dic)->key) ||
2146 IC_RESULT (ic)->key == IC_RIGHT (dic)->key)))
2150 /* found the definition */
2151 /* replace the result with the result of */
2152 /* this assignment and remove this assignment */
2153 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2155 IC_RESULT (dic) = IC_RESULT (ic);
2157 if (IS_ITEMP (IC_RESULT (dic)) && OP_SYMBOL (IC_RESULT (dic))->liveFrom > dic->seq)
2159 OP_SYMBOL (IC_RESULT (dic))->liveFrom = dic->seq;
2161 /* delete from liverange table also
2162 delete from all the points inbetween and the new
2164 for (sic = dic; sic != ic; sic = sic->next)
2166 bitVectUnSetBit (sic->rlive, IC_RESULT (ic)->key);
2167 if (IS_ITEMP (IC_RESULT (dic)))
2168 bitVectSetBit (sic->rlive, IC_RESULT (dic)->key);
2171 remiCodeFromeBBlock (ebp, ic);
2172 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
2173 hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
2174 OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
2178 /*------------------------------------------------------------------*/
2179 /* findAssignToSym : scanning backwards looks for first assig found */
2180 /*------------------------------------------------------------------*/
2182 findAssignToSym (operand * op, iCode * ic)
2186 /* This routine is used to find sequences like
2188 ...; (intervening ops don't use iTempAA or modify FOO)
2189 blah = blah + iTempAA;
2191 and eliminate the use of iTempAA, freeing up its register for
2195 for (dic = ic->prev; dic; dic = dic->prev)
2198 /* if definition by assignment */
2199 if (dic->op == '=' &&
2200 !POINTER_SET (dic) &&
2201 IC_RESULT (dic)->key == op->key
2202 /* && IS_TRUE_SYMOP(IC_RIGHT(dic)) */
2206 /* we are interested only if defined in far space */
2207 /* or in stack space in case of + & - */
2209 /* if assigned to a non-symbol then return
2211 if (!IS_SYMOP (IC_RIGHT (dic)))
2214 /* if the symbol is in far space then
2216 if (isOperandInFarSpace (IC_RIGHT (dic)))
2219 /* for + & - operations make sure that
2220 if it is on the stack it is the same
2221 as one of the three operands */
2222 if ((ic->op == '+' || ic->op == '-') &&
2223 OP_SYMBOL (IC_RIGHT (dic))->onStack)
2226 if (IC_RESULT (ic)->key != IC_RIGHT (dic)->key &&
2227 IC_LEFT (ic)->key != IC_RIGHT (dic)->key &&
2228 IC_RIGHT (ic)->key != IC_RIGHT (dic)->key)
2236 /* if we find an usage then we cannot delete it */
2237 if (IC_LEFT (dic) && IC_LEFT (dic)->key == op->key)
2240 if (IC_RIGHT (dic) && IC_RIGHT (dic)->key == op->key)
2243 if (POINTER_SET (dic) && IC_RESULT (dic)->key == op->key)
2247 /* now make sure that the right side of dic
2248 is not defined between ic & dic */
2251 iCode *sic = dic->next;
2253 for (; sic != ic; sic = sic->next)
2254 if (IC_RESULT (sic) &&
2255 IC_RESULT (sic)->key == IC_RIGHT (dic)->key)
2264 /*-----------------------------------------------------------------*/
2265 /* packRegsForSupport :- reduce some registers for support calls */
2266 /*-----------------------------------------------------------------*/
2268 packRegsForSupport (iCode * ic, eBBlock * ebp)
2272 /* for the left & right operand :- look to see if the
2273 left was assigned a true symbol in far space in that
2274 case replace them */
2275 if (IS_ITEMP (IC_LEFT (ic)) &&
2276 OP_SYMBOL (IC_LEFT (ic))->liveTo <= ic->seq)
2278 iCode *dic = findAssignToSym (IC_LEFT (ic), ic);
2284 /* found it we need to remove it from the
2286 for (sic = dic; sic != ic; sic = sic->next) {
2287 bitVectUnSetBit (sic->rlive, IC_LEFT (ic)->key);
2288 sic->rlive = bitVectSetBit (sic->rlive, IC_RIGHT (dic)->key);
2291 wassert(IS_SYMOP(IC_LEFT (ic)));
2292 wassert(IS_SYMOP(IC_RIGHT (dic)));
2293 IC_LEFT (ic)->operand.symOperand =
2294 IC_RIGHT (dic)->operand.symOperand;
2295 OP_SYMBOL(IC_LEFT(ic))->liveTo = ic->seq;
2296 IC_LEFT (ic)->key = IC_RIGHT (dic)->operand.symOperand->key;
2297 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2298 remiCodeFromeBBlock (ebp, dic);
2299 hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2303 /* do the same for the right operand */
2306 IS_ITEMP (IC_RIGHT (ic)) &&
2307 OP_SYMBOL (IC_RIGHT (ic))->liveTo <= ic->seq)
2309 iCode *dic = findAssignToSym (IC_RIGHT (ic), ic);
2315 /* if this is a subtraction & the result
2316 is a true symbol in far space then don't pack */
2317 if (ic->op == '-' && IS_TRUE_SYMOP (IC_RESULT (dic)))
2319 sym_link *etype = getSpec (operandType (IC_RESULT (dic)));
2320 if (IN_FARSPACE (SPEC_OCLS (etype)))
2323 /* found it we need to remove it from the
2325 for (sic = dic; sic != ic; sic = sic->next) {
2326 bitVectUnSetBit (sic->rlive, IC_RIGHT (ic)->key);
2327 sic->rlive = bitVectSetBit (sic->rlive, IC_RIGHT (dic)->key);
2330 wassert(IS_SYMOP(IC_RIGHT (ic)));
2331 wassert(IS_SYMOP(IC_RIGHT (dic)));
2332 IC_RIGHT (ic)->operand.symOperand =
2333 IC_RIGHT (dic)->operand.symOperand;
2334 IC_RIGHT (ic)->key = IC_RIGHT (dic)->operand.symOperand->key;
2335 OP_SYMBOL(IC_RIGHT(ic))->liveTo = ic->seq;
2336 remiCodeFromeBBlock (ebp, dic);
2337 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2338 hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2345 #define IS_OP_RUONLY(x) (x && IS_SYMOP(x) && OP_SYMBOL(x)->ruonly)
2348 /*-----------------------------------------------------------------*/
2349 /* packRegsDPTRnuse - color live ranges that can go into extra DPTRS */
2350 /*-----------------------------------------------------------------*/
2351 static int packRegsDPTRnuse( operand *op , unsigned dptr)
2356 if (!IS_SYMOP(op) || !IS_ITEMP(op)) return 0;
2357 if (OP_SYMBOL(op)->remat || OP_SYMBOL(op)->ruonly || OP_SYMBOL(op)->dptr)
2360 /* first check if any overlapping liverange has already been
2361 assigned to this DPTR */
2362 if (OP_SYMBOL(op)->clashes) {
2363 for (i = 0 ; i < OP_SYMBOL(op)->clashes->size ; i++ ) {
2365 if (bitVectBitValue(OP_SYMBOL(op)->clashes,i)) {
2366 sym = hTabItemWithKey(liveRanges,i);
2367 if (sym->dptr == dptr) return 0;
2372 /* future for more dptrs */
2374 OP_SYMBOL(op)->dptr = dptr;
2378 /* DPTR1 is special since it is also used as a scratch by the backend .
2379 so we walk thru the entire live range of this operand and make sure
2380 DPTR1 will not be used by the backed . The logic here is to find out if
2381 more than one operand in an icode is in far space then we give up : we
2382 don't keep it live across functions for now
2385 ic = hTabFirstItemWK(iCodeSeqhTab,OP_SYMBOL(op)->liveFrom);
2386 for (; ic && ic->seq <= OP_SYMBOL(op)->liveTo;
2387 ic = hTabNextItem(iCodeSeqhTab,&key)) {
2390 if (ic->op == CALL || ic->op == PCALL) return 0;
2392 /* single operand icode are ok */
2393 if (ic->op == IFX || ic->op == IPUSH)
2396 if (ic->op == SEND ) {
2397 if (ic->argreg != 1 ) return 0;
2400 /* two special cases first */
2401 if (POINTER_GET(ic) && !isOperandEqual(IC_LEFT(ic),op) && /* pointer get */
2402 !OP_SYMBOL(IC_LEFT(ic))->ruonly && /* with result in far space */
2403 (isOperandInFarSpace(IC_RESULT(ic)) &&
2404 !isOperandInReg(IC_RESULT(ic)))) {
2408 if (POINTER_SET(ic) && !isOperandEqual(IC_RESULT(ic),op) && /* pointer set */
2409 !OP_SYMBOL(IC_RESULT(ic))->ruonly && /* with right in far space */
2410 (isOperandInFarSpace(IC_RIGHT(ic)) &&
2411 !isOperandInReg(IC_RIGHT(ic)))) {
2415 if (IC_RESULT(ic) && IS_SYMOP(IC_RESULT(ic)) && /* if symbol operand */
2416 !isOperandEqual(IC_RESULT(ic),op) && /* not the same as this */
2417 ((isOperandInFarSpace(IC_RESULT(ic)) || /* in farspace or */
2418 OP_SYMBOL(IC_RESULT(ic))->onStack) && /* on the stack */
2419 !isOperandInReg(IC_RESULT(ic)))) { /* and not in register */
2423 if (IC_LEFT(ic) && IS_SYMOP(IC_LEFT(ic)) && /* if symbol operand */
2424 !isOperandEqual(IC_LEFT(ic),op) && /* not the same as this */
2425 ((isOperandInFarSpace(IC_LEFT(ic)) || /* in farspace or */
2426 OP_SYMBOL(IC_LEFT(ic))->onStack) && /* on the stack */
2427 !isOperandInReg(IC_LEFT(ic)))) { /* and not in register */
2430 /* same for right */
2431 if (IC_RIGHT(ic) && IS_SYMOP(IC_RIGHT(ic)) && /* if symbol operand */
2432 !isOperandEqual(IC_RIGHT(ic),op) && /* not the same as this */
2433 ((isOperandInFarSpace(IC_RIGHT(ic)) || /* in farspace or */
2434 OP_SYMBOL(IC_RIGHT(ic))->onStack) && /* on the stack */
2435 !isOperandInReg(IC_RIGHT(ic)))) { /* and not in register */
2439 // Check that no other ops in this range have been assigned to dptr1.
2440 // I don't understand why this is not caught by the first check, above.
2441 // But it isn't always, see bug 769624.
2442 if (IC_RESULT(ic) && IS_SYMOP(IC_RESULT(ic)) &&
2443 (OP_SYMBOL(IC_RESULT(ic))->dptr == 1))
2445 //fprintf(stderr, "dptr1 already in use in live range #1\n");
2449 if (IC_LEFT(ic) && IS_SYMOP(IC_LEFT(ic)) &&
2450 (OP_SYMBOL(IC_LEFT(ic))->dptr == 1))
2452 //fprintf(stderr, "dptr1 already in use in live range # 2\n");
2456 if (IC_RIGHT(ic) && IS_SYMOP(IC_RIGHT(ic)) &&
2457 (OP_SYMBOL(IC_RIGHT(ic))->dptr == 1))
2459 //fprintf(stderr, "dptr1 already in use in live range # 3\n");
2463 if (nfs && IC_RESULT(ic) && IS_SYMOP(IC_RESULT(ic)) &&
2464 OP_SYMBOL(IC_RESULT(ic))->ruonly) return 0;
2466 if (nfs > 1) return 0;
2468 OP_SYMBOL(op)->dptr = dptr;
2472 /*-----------------------------------------------------------------*/
2473 /* packRegsDPTRuse : - will reduce some registers for single Use */
2474 /*-----------------------------------------------------------------*/
2476 packRegsDPTRuse (operand * op)
2478 /* go thru entire liveRange of this variable & check for
2479 other possible usage of DPTR , if we don't find it the
2480 assign this to DPTR (ruonly)
2485 sym_link *type, *etype;
2487 if (!IS_SYMOP(op) || !IS_ITEMP(op)) return NULL;
2488 if (OP_SYMBOL(op)->remat || OP_SYMBOL(op)->ruonly) return NULL;
2490 /* first check if any overlapping liverange has already been
2492 if (OP_SYMBOL(op)->clashes) {
2493 for (i = 0 ; i < OP_SYMBOL(op)->clashes->size ; i++ ) {
2494 if (bitVectBitValue(OP_SYMBOL(op)->clashes,i)) {
2495 sym = hTabItemWithKey(liveRanges,i);
2496 if (sym->ruonly) return NULL ;
2501 /* no then go thru this guys live range */
2502 dic = ic = hTabFirstItemWK(iCodeSeqhTab,OP_SYMBOL(op)->liveFrom);
2503 for (; ic && ic->seq <= OP_SYMBOL(op)->liveTo;
2504 ic = hTabNextItem(iCodeSeqhTab,&key)) {
2506 if (SKIP_IC3(ic)) continue;
2508 /* if PCALL cannot be sure give up */
2509 if (ic->op == PCALL) return NULL;
2511 /* if SEND & not the first parameter then giveup */
2512 if (ic->op == SEND && ic->argreg != 1 &&
2513 ((isOperandInFarSpace(IC_LEFT(ic)) && !isOperandInReg(IC_LEFT(ic))) ||
2514 isOperandEqual(op,IC_LEFT(ic)))) return NULL;
2516 /* if CALL then make sure it is VOID || return value not used
2517 or the return value is assigned to this one */
2518 if (ic->op == CALL) {
2519 if (OP_SYMBOL(IC_RESULT(ic))->liveTo ==
2520 OP_SYMBOL(IC_RESULT(ic))->liveFrom) continue ;
2521 etype = getSpec(type = operandType(IC_RESULT(ic)));
2522 if (getSize(type) == 0 || isOperandEqual(op,IC_RESULT(ic)))
2527 /* special case of add with a [remat] */
2528 if (ic->op == '+' &&
2529 OP_SYMBOL(IC_LEFT(ic))->remat &&
2530 (isOperandInFarSpace(IC_RIGHT(ic)) &&
2531 !isOperandInReg(IC_RIGHT(ic)))) return NULL ;
2535 if (POINTER_GET(ic) && !isOperandEqual(IC_LEFT(ic),op) &&
2536 getSize(operandType(IC_LEFT(ic))) > 1 ) return NULL ;
2539 if (POINTER_SET(ic) && !isOperandEqual(IC_RESULT(ic),op) &&
2540 getSize(operandType(IC_RESULT(ic))) > 1 ) return NULL;
2542 /* conditionals can destroy 'b' - make sure B wont
2543 be used in this one*/
2544 if ((IS_CONDITIONAL(ic) || ic->op == '*' || ic->op == '/' ||
2545 ic->op == LEFT_OP || ic->op == RIGHT_OP ) &&
2546 getSize(operandType(op)) > 3) return NULL;
2548 /* if this is a cast to a bigger type */
2550 if (!IS_PTR(OP_SYM_TYPE(IC_RESULT(ic))) &&
2551 getSize(OP_SYM_TYPE(IC_RESULT(ic))) >
2552 getSize(OP_SYM_TYPE(IC_RIGHT(ic)))) {
2558 if (IC_RESULT(ic) && IS_SYMOP(IC_RESULT(ic)) &&
2559 !isOperandEqual(IC_RESULT(ic),op) &&
2560 ( ( ( isOperandInFarSpace(IC_RESULT(ic)) || OP_SYMBOL(IC_RESULT(ic))->onStack) &&
2561 !isOperandInReg(IC_RESULT(ic))) ||
2562 OP_SYMBOL(IC_RESULT(ic))->ruonly)) return NULL;
2564 if (IC_RIGHT(ic) && IS_SYMOP(IC_RIGHT(ic)) &&
2565 !isOperandEqual(IC_RIGHT(ic),op) &&
2566 (OP_SYMBOL(IC_RIGHT(ic))->liveTo >= ic->seq ||
2567 IS_TRUE_SYMOP(IC_RIGHT(ic)) ||
2568 OP_SYMBOL(IC_RIGHT(ic))->ruonly) &&
2569 ( ( isOperandInFarSpace(IC_RIGHT(ic)) || OP_SYMBOL(IC_RIGHT(ic))->onStack) &&
2570 !isOperandInReg(IC_RIGHT(ic))) ) return NULL;
2572 if (IC_LEFT(ic) && IS_SYMOP(IC_LEFT(ic)) &&
2573 !isOperandEqual(IC_LEFT(ic),op) &&
2574 (OP_SYMBOL(IC_LEFT(ic))->liveTo >= ic->seq ||
2575 IS_TRUE_SYMOP(IC_LEFT(ic)) ||
2576 OP_SYMBOL(IC_LEFT(ic))->ruonly) &&
2577 ( ( isOperandInFarSpace(IC_LEFT(ic)) || OP_SYMBOL(IC_LEFT(ic))->onStack) &&
2578 !isOperandInReg(IC_LEFT(ic))) ) return NULL;
2580 if (IC_LEFT(ic) && IC_RIGHT(ic) &&
2581 IS_ITEMP(IC_LEFT(ic)) && IS_ITEMP(IC_RIGHT(ic)) &&
2582 (isOperandInFarSpace(IC_LEFT(ic)) && !isOperandInReg(IC_LEFT(ic))) &&
2583 (isOperandInFarSpace(IC_RIGHT(ic)) && !isOperandInReg(IC_RIGHT(ic))))
2586 OP_SYMBOL(op)->ruonly = 1;
2587 if (OP_SYMBOL(op)->usl.spillLoc) {
2588 if (OP_SYMBOL(op)->spillA)
2589 OP_SYMBOL(op)->usl.spillLoc->allocreq--;
2590 OP_SYMBOL(op)->usl.spillLoc = NULL;
2595 /*-----------------------------------------------------------------*/
2596 /* isBitwiseOptimizable - requirements of JEAN LOUIS VERN */
2597 /*-----------------------------------------------------------------*/
2599 isBitwiseOptimizable (iCode * ic)
2601 sym_link *ltype = getSpec (operandType (IC_LEFT (ic)));
2602 sym_link *rtype = getSpec (operandType (IC_RIGHT (ic)));
2604 /* bitwise operations are considered optimizable
2605 under the following conditions (Jean-Louis VERN)
2617 if (IS_LITERAL (rtype) ||
2618 (IS_BITVAR (ltype) && IN_BITSPACE (SPEC_OCLS (ltype))))
2624 /*-----------------------------------------------------------------*/
2625 /* packRegsForAccUse - pack registers for acc use */
2626 /*-----------------------------------------------------------------*/
2628 packRegsForAccUse (iCode * ic)
2632 /* if this is an aggregate, e.g. a one byte char array */
2633 if (IS_AGGREGATE(operandType(IC_RESULT(ic)))) {
2637 /* if we are calling a reentrant function that has stack parameters */
2638 if (ic->op == CALL &&
2639 IFFUNC_ISREENT(operandType(IC_LEFT(ic))) &&
2640 FUNC_HASSTACKPARM(operandType(IC_LEFT(ic))))
2643 if (ic->op == PCALL &&
2644 IFFUNC_ISREENT(operandType(IC_LEFT(ic))->next) &&
2645 FUNC_HASSTACKPARM(operandType(IC_LEFT(ic))->next))
2648 /* if + or - then it has to be one byte result */
2649 if ((ic->op == '+' || ic->op == '-')
2650 && getSize (operandType (IC_RESULT (ic))) > 1)
2653 /* if shift operation make sure right side is not a literal */
2654 if (ic->op == RIGHT_OP &&
2655 (isOperandLiteral (IC_RIGHT (ic)) ||
2656 getSize (operandType (IC_RESULT (ic))) > 1))
2659 if (ic->op == LEFT_OP &&
2660 (isOperandLiteral (IC_RIGHT (ic)) ||
2661 getSize (operandType (IC_RESULT (ic))) > 1))
2664 if (IS_BITWISE_OP (ic) &&
2665 getSize (operandType (IC_RESULT (ic))) > 1)
2669 /* has only one definition */
2670 if (bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) > 1)
2673 /* has only one use */
2674 if (bitVectnBitsOn (OP_USES (IC_RESULT (ic))) > 1)
2677 /* and the usage immediately follows this iCode */
2678 if (!(uic = hTabItemWithKey (iCodehTab,
2679 bitVectFirstBit (OP_USES (IC_RESULT (ic))))))
2682 if (ic->next != uic)
2685 /* if it is a conditional branch then we definitely can */
2689 if (uic->op == JUMPTABLE)
2692 /* if the usage is not is an assignment
2693 or an arithmetic / bitwise / shift operation then not */
2694 if (POINTER_SET (uic) &&
2695 getSize (aggrToPtr (operandType (IC_RESULT (uic)), FALSE)) > 1)
2698 if (uic->op != '=' &&
2699 !IS_ARITHMETIC_OP (uic) &&
2700 !IS_BITWISE_OP (uic) &&
2701 uic->op != LEFT_OP &&
2702 uic->op != RIGHT_OP)
2705 /* if used in ^ operation then make sure right is not a
2707 if (uic->op == '^' && isOperandLiteral (IC_RIGHT (uic)))
2710 /* if shift operation make sure right side is not a literal */
2711 if (uic->op == RIGHT_OP &&
2712 (isOperandLiteral (IC_RIGHT (uic)) ||
2713 getSize (operandType (IC_RESULT (uic))) > 1))
2716 if (uic->op == LEFT_OP &&
2717 (isOperandLiteral (IC_RIGHT (uic)) ||
2718 getSize (operandType (IC_RESULT (uic))) > 1))
2721 /* make sure that the result of this icode is not on the
2722 stack, since acc is used to compute stack offset */
2723 if (isOperandOnStack(IC_RESULT(uic)))
2726 /* if either one of them in far space then we cannot */
2727 if ((IS_TRUE_SYMOP (IC_LEFT (uic)) &&
2728 isOperandInFarSpace (IC_LEFT (uic))) ||
2729 (IS_TRUE_SYMOP (IC_RIGHT (uic)) &&
2730 isOperandInFarSpace (IC_RIGHT (uic))))
2733 /* if the usage has only one operand then we can */
2734 if (IC_LEFT (uic) == NULL ||
2735 IC_RIGHT (uic) == NULL)
2738 /* make sure this is on the left side if not
2739 a '+' since '+' is commutative */
2740 if (ic->op != '+' &&
2741 IC_LEFT (uic)->key != IC_RESULT (ic)->key)
2744 /* if the other one is not on stack then we can */
2745 if (IC_LEFT (uic)->key == IC_RESULT (ic)->key &&
2746 (IS_ITEMP (IC_RIGHT (uic)) ||
2747 (IS_TRUE_SYMOP (IC_RIGHT (uic)) &&
2748 !OP_SYMBOL (IC_RIGHT (uic))->onStack)))
2751 if (IC_RIGHT (uic)->key == IC_RESULT (ic)->key &&
2752 (IS_ITEMP (IC_LEFT (uic)) ||
2753 (IS_TRUE_SYMOP (IC_LEFT (uic)) &&
2754 !OP_SYMBOL (IC_LEFT (uic))->onStack)))
2760 OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
2764 /*-----------------------------------------------------------------*/
2765 /* packForPush - hueristics to reduce iCode for pushing */
2766 /*-----------------------------------------------------------------*/
2768 packForPush (iCode * ic, eBBlock * ebp)
2773 if ((ic->op != IPUSH && ic->op != SEND) || !IS_ITEMP (IC_LEFT (ic)))
2776 /* must have only definition & one usage */
2777 if (bitVectnBitsOn (OP_DEFS (IC_LEFT (ic))) != 1 ||
2778 bitVectnBitsOn (OP_USES (IC_LEFT (ic))) != 1)
2781 /* find the definition */
2782 if (!(dic = hTabItemWithKey (iCodehTab,
2783 bitVectFirstBit (OP_DEFS (IC_LEFT (ic))))))
2786 if (dic->op != '=' || POINTER_SET (dic))
2789 if (dic->eBBlockNum != ic->eBBlockNum) return ;
2791 /* make sure the right side does not have any definitions
2793 dbv = OP_DEFS(IC_RIGHT(dic));
2794 for (lic = ic; lic && lic != dic ; lic = lic->prev) {
2795 if (bitVectBitValue(dbv,lic->key)) return ;
2797 /* make sure they have the same type */
2798 if (IS_SPEC(operandType(IC_LEFT(ic))))
2800 sym_link *itype=operandType(IC_LEFT(ic));
2801 sym_link *ditype=operandType(IC_RIGHT(dic));
2803 if (SPEC_USIGN(itype)!=SPEC_USIGN(ditype) ||
2804 SPEC_LONG(itype)!=SPEC_LONG(ditype))
2807 /* extend the live range of replaced operand if needed */
2808 if (OP_SYMBOL(IC_RIGHT(dic))->liveTo < OP_SYMBOL(IC_LEFT(ic))->liveTo) {
2809 OP_SYMBOL(IC_RIGHT(dic))->liveTo = OP_SYMBOL(IC_LEFT(ic))->liveTo;
2810 OP_SYMBOL(IC_RIGHT(dic))->clashes =
2811 bitVectUnion(OP_SYMBOL(IC_RIGHT(dic))->clashes,
2812 OP_SYMBOL(IC_LEFT(ic))->clashes);
2814 for (lic = ic; lic && lic != dic; lic = lic->prev)
2816 bitVectUnSetBit (lic->rlive, IC_LEFT (ic)->key);
2817 if (IS_ITEMP (IC_RIGHT (dic)))
2818 bitVectSetBit (lic->rlive, IC_RIGHT (dic)->key);
2820 /* we now we know that it has one & only one def & use
2821 and the that the definition is an assignment */
2822 IC_LEFT (ic) = IC_RIGHT (dic);
2824 remiCodeFromeBBlock (ebp, dic);
2825 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2826 hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2829 /*-----------------------------------------------------------------*/
2830 /* packRegisters - does some transformations to reduce register */
2832 /*-----------------------------------------------------------------*/
2834 packRegisters (eBBlock * ebp)
2844 /* look for assignments of the form */
2845 /* iTempNN = TRueSym (someoperation) SomeOperand */
2847 /* TrueSym := iTempNN:1 */
2848 for (ic = ebp->sch; ic; ic = ic->next)
2850 /* find assignment of the form TrueSym := iTempNN:1 */
2851 if (ic->op == '=' && !POINTER_SET (ic))
2852 change += packRegsForAssign (ic, ebp);
2859 for (ic = ebp->sch; ic; ic = ic->next)
2861 /* if this is an itemp & result of an address of a true sym
2862 then mark this as rematerialisable */
2863 if (ic->op == ADDRESS_OF &&
2864 IS_ITEMP (IC_RESULT (ic)) &&
2865 IS_TRUE_SYMOP (IC_LEFT (ic)) &&
2866 bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
2867 !OP_SYMBOL (IC_LEFT (ic))->onStack)
2870 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2871 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2872 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2876 /* if this is an itemp & used as a pointer
2877 & assigned to a literal then remat */
2878 if (IS_ASSIGN_ICODE(ic) &&
2879 IS_ITEMP(IC_RESULT(ic)) &&
2880 bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
2881 isOperandLiteral(IC_RIGHT(ic)))
2883 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2884 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2885 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2888 /* if straight assignment then carry remat flag if
2889 this is the only definition */
2890 if (ic->op == '=' &&
2891 !POINTER_SET (ic) &&
2892 IS_SYMOP (IC_RIGHT (ic)) &&
2893 OP_SYMBOL (IC_RIGHT (ic))->remat &&
2894 !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode) &&
2895 bitVectnBitsOn (OP_SYMBOL (IC_RESULT (ic))->defs) <= 1)
2898 OP_SYMBOL (IC_RESULT (ic))->remat =
2899 OP_SYMBOL (IC_RIGHT (ic))->remat;
2900 OP_SYMBOL (IC_RESULT (ic))->rematiCode =
2901 OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
2904 /* if cast to a generic pointer & the pointer being
2905 cast is remat, then we can remat this cast as well */
2906 if (ic->op == CAST &&
2907 IS_SYMOP(IC_RIGHT(ic)) &&
2908 !OP_SYMBOL(IC_RESULT(ic))->isreqv &&
2909 OP_SYMBOL(IC_RIGHT(ic))->remat ) {
2910 sym_link *to_type = operandType(IC_LEFT(ic));
2911 sym_link *from_type = operandType(IC_RIGHT(ic));
2912 if (IS_GENPTR(to_type) && IS_PTR(from_type)) {
2913 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2914 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2915 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2919 /* if this is a +/- operation with a rematerizable
2920 then mark this as rematerializable as well */
2921 if ((ic->op == '+' || ic->op == '-') &&
2922 (IS_SYMOP (IC_LEFT (ic)) &&
2923 IS_ITEMP (IC_RESULT (ic)) &&
2924 OP_SYMBOL (IC_LEFT (ic))->remat &&
2925 (!IS_SYMOP (IC_RIGHT (ic)) || !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode)) &&
2926 bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
2927 IS_OP_LITERAL (IC_RIGHT (ic))))
2930 //int i = operandLitValue(IC_RIGHT(ic));
2931 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2932 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2933 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2936 /* mark the pointer usages */
2937 if (POINTER_SET (ic) && IS_SYMOP (IC_RESULT (ic)))
2938 OP_SYMBOL (IC_RESULT (ic))->uptr = 1;
2940 if (POINTER_GET (ic) && IS_SYMOP (IC_LEFT (ic)))
2941 OP_SYMBOL (IC_LEFT (ic))->uptr = 1;
2943 if (ic->op == RETURN && IS_SYMOP (IC_LEFT(ic)))
2944 OP_SYMBOL (IC_LEFT (ic))->uptr = 1;
2946 if (ic->op == RECEIVE && ic->argreg == 1 &&
2947 IS_SYMOP (IC_RESULT (ic)) &&
2948 getSize (operandType(IC_RESULT(ic))) <= 3)
2949 OP_SYMBOL (IC_RESULT(ic))->uptr = 1;
2951 if (ic->op == SEND && ic->argreg == 1 &&
2952 IS_SYMOP(IC_LEFT(ic)) &&
2953 getSize (aggrToPtr(operandType(IC_LEFT(ic)),FALSE)) <= 3)
2954 OP_SYMBOL (IC_LEFT(ic))->uptr = 1;
2958 /* if we are using a symbol on the stack
2959 then we should say ds390_ptrRegReq */
2960 if (options.useXstack && ic->parmPush
2961 && (ic->op == IPUSH || ic->op == IPOP))
2963 if (ic->op == IFX && IS_SYMOP (IC_COND (ic)))
2964 ds390_ptrRegReq += ((OP_SYMBOL (IC_COND (ic))->onStack ? !options.stack10bit : 0) +
2965 OP_SYMBOL (IC_COND (ic))->iaccess +
2966 (SPEC_OCLS(OP_SYMBOL (IC_COND (ic))->etype) == idata));
2967 else if (ic->op == JUMPTABLE && IS_SYMOP (IC_JTCOND (ic)))
2968 ds390_ptrRegReq += ((OP_SYMBOL (IC_JTCOND (ic))->onStack ? !options.stack10bit : 0) +
2969 OP_SYMBOL (IC_JTCOND (ic))->iaccess +
2970 (SPEC_OCLS(OP_SYMBOL (IC_JTCOND (ic))->etype) == idata));
2973 if (IS_SYMOP (IC_LEFT (ic)))
2974 ds390_ptrRegReq += ((OP_SYMBOL (IC_LEFT (ic))->onStack ? !options.stack10bit : 0) +
2975 OP_SYMBOL (IC_LEFT (ic))->iaccess +
2976 (SPEC_OCLS(OP_SYMBOL (IC_LEFT (ic))->etype) == idata));
2977 if (IS_SYMOP (IC_RIGHT (ic)))
2978 ds390_ptrRegReq += ((OP_SYMBOL (IC_RIGHT (ic))->onStack ? !options.stack10bit : 0) +
2979 OP_SYMBOL (IC_RIGHT (ic))->iaccess +
2980 (SPEC_OCLS(OP_SYMBOL (IC_RIGHT (ic))->etype) == idata));
2981 if (IS_SYMOP (IC_RESULT (ic)))
2982 ds390_ptrRegReq += ((OP_SYMBOL (IC_RESULT (ic))->onStack ? !options.stack10bit : 0) +
2983 OP_SYMBOL (IC_RESULT (ic))->iaccess +
2984 (SPEC_OCLS(OP_SYMBOL (IC_RESULT (ic))->etype) == idata));
2988 /* if the condition of an if instruction
2989 is defined in the previous instruction and
2990 this is the only usage then
2991 mark the itemp as a conditional */
2992 if ((IS_CONDITIONAL (ic) ||
2993 (IS_BITWISE_OP(ic) && isBitwiseOptimizable (ic))) &&
2994 ic->next && ic->next->op == IFX &&
2995 bitVectnBitsOn (OP_USES(IC_RESULT(ic)))==1 &&
2996 isOperandEqual (IC_RESULT (ic), IC_COND (ic->next)) &&
2997 OP_SYMBOL (IC_RESULT (ic))->liveTo <= ic->next->seq)
2999 OP_SYMBOL (IC_RESULT (ic))->regType = REG_CND;
3003 /* reduce for support function calls */
3004 if (ic->supportRtn || ic->op == '+' || ic->op == '-')
3005 packRegsForSupport (ic, ebp);
3007 /* some cases the redundant moves can
3008 can be eliminated for return statements . Can be elminated for the first SEND */
3009 if ((ic->op == RETURN ||
3010 ((ic->op == SEND || ic->op == RECEIVE)&& ic->argreg == 1)) &&
3011 !isOperandInFarSpace (IC_LEFT (ic)) &&
3014 packRegsDPTRuse (IC_LEFT (ic));
3017 if (ic->op == CALL) {
3018 sym_link *ftype = operandType(IC_LEFT(ic));
3019 if (getSize(operandType(IC_RESULT(ic))) <= 4 &&
3020 !IFFUNC_ISBUILTIN(ftype)) {
3021 packRegsDPTRuse (IC_RESULT (ic));
3025 /* if pointer set & left has a size more than
3026 one and right is not in far space */
3027 if (POINTER_SET (ic) &&
3028 !isOperandInFarSpace (IC_RIGHT (ic)) &&
3029 IS_SYMOP (IC_RESULT (ic)) &&
3030 !OP_SYMBOL (IC_RESULT (ic))->remat &&
3031 !IS_OP_RUONLY (IC_RIGHT (ic)) &&
3032 getSize (aggrToPtr (operandType (IC_RESULT (ic)), FALSE)) > 1) {
3034 packRegsDPTRuse (IC_RESULT (ic));
3037 /* if pointer get */
3038 if (POINTER_GET (ic) &&
3039 !isOperandInFarSpace (IC_RESULT (ic)) &&
3040 IS_SYMOP (IC_LEFT (ic)) &&
3041 !OP_SYMBOL (IC_LEFT (ic))->remat &&
3042 !IS_OP_RUONLY (IC_RESULT (ic)) &&
3043 getSize (aggrToPtr (operandType (IC_LEFT (ic)), FALSE)) > 1) {
3045 packRegsDPTRuse (IC_LEFT (ic));
3048 /* if this is cast for intergral promotion then
3049 check if only use of the definition of the
3050 operand being casted/ if yes then replace
3051 the result of that arithmetic operation with
3052 this result and get rid of the cast */
3055 sym_link *fromType = operandType (IC_RIGHT (ic));
3056 sym_link *toType = operandType (IC_LEFT (ic));
3058 if (IS_INTEGRAL (fromType) && IS_INTEGRAL (toType) &&
3059 getSize (fromType) != getSize (toType) &&
3060 SPEC_USIGN (fromType) == SPEC_USIGN (toType))
3063 iCode *dic = packRegsDPTRuse (IC_RIGHT (ic));
3066 if (IS_ARITHMETIC_OP (dic))
3068 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
3069 IC_RESULT (dic) = IC_RESULT (ic);
3070 remiCodeFromeBBlock (ebp, ic);
3071 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
3072 hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
3073 OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
3077 OP_SYMBOL (IC_RIGHT (ic))->ruonly = 0;
3083 /* if the type from and type to are the same
3084 then if this is the only use then packit */
3085 if (compareType (operandType (IC_RIGHT (ic)),
3086 operandType (IC_LEFT (ic))) == 1)
3088 iCode *dic = packRegsDPTRuse (IC_RIGHT (ic));
3091 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
3092 IC_RESULT (dic) = IC_RESULT (ic);
3093 remiCodeFromeBBlock (ebp, ic);
3094 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
3095 hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
3096 OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
3104 iTempNN := (some variable in farspace) V1
3109 if (ic->op == IPUSH || ic->op == SEND)
3111 packForPush (ic, ebp);
3115 /* pack registers for accumulator use, when the
3116 result of an arithmetic or bit wise operation
3117 has only one use, that use is immediately following
3118 the defintion and the using iCode has only one
3119 operand or has two operands but one is literal &
3120 the result of that operation is not on stack then
3121 we can leave the result of this operation in acc:b
3123 if ((IS_ARITHMETIC_OP (ic)
3124 || IS_CONDITIONAL(ic)
3125 || IS_BITWISE_OP (ic)
3126 || ic->op == LEFT_OP || ic->op == RIGHT_OP
3127 || (ic->op == ADDRESS_OF && isOperandOnStack (IC_LEFT (ic)))
3129 IS_ITEMP (IC_RESULT (ic)) &&
3130 getSize (operandType (IC_RESULT (ic))) <= 2)
3132 packRegsForAccUse (ic);
3137 /*-----------------------------------------------------------------*/
3138 /* assignRegisters - assigns registers to each live range as need */
3139 /*-----------------------------------------------------------------*/
3141 ds390_assignRegisters (ebbIndex * ebbi)
3143 eBBlock ** ebbs = ebbi->bbOrder;
3144 int count = ebbi->count;
3148 setToNull ((void *) &_G.funcrUsed);
3149 setToNull ((void *) &_G.regAssigned);
3150 setToNull ((void *) &_G.totRegAssigned);
3151 setToNull ((void *) &_G.funcrUsed);
3152 ds390_ptrRegReq = _G.stackExtend = _G.dataExtend = 0;
3154 if (options.model != MODEL_FLAT24) options.stack10bit = 0;
3155 /* change assignments this will remove some
3156 live ranges reducing some register pressure */
3157 for (i = 0; i < count; i++)
3158 packRegisters (ebbs[i]);
3160 /* liveranges probably changed by register packing
3161 so we compute them again */
3162 recomputeLiveRanges (ebbs, count);
3164 if (options.dump_pack)
3165 dumpEbbsToFileExt (DUMP_PACK, ebbi);
3167 /* first determine for each live range the number of
3168 registers & the type of registers required for each */
3171 /* and serially allocate registers */
3172 serialRegAssign (ebbs, count);
3179 /* if stack was extended then tell the user */
3182 /* werror(W_TOOMANY_SPILS,"stack", */
3183 /* _G.stackExtend,currFunc->name,""); */
3189 /* werror(W_TOOMANY_SPILS,"data space", */
3190 /* _G.dataExtend,currFunc->name,""); */
3194 /* after that create the register mask
3195 for each of the instruction */
3196 createRegMask (ebbs, count);
3198 /* redo that offsets for stacked automatic variables */
3200 redoStackOffsets ();
3202 /* make sure r0 & r1 are flagged as used if they might be used */
3204 if (currFunc && ds390_ptrRegReq)
3206 currFunc->regsUsed = bitVectSetBit (currFunc->regsUsed, R0_IDX);
3207 currFunc->regsUsed = bitVectSetBit (currFunc->regsUsed, R1_IDX);
3210 if (options.dump_rassgn) {
3211 dumpEbbsToFileExt (DUMP_RASSGN, ebbi);
3212 dumpLiveRanges (DUMP_LRANGE, liveRanges);
3215 /* do the overlaysegment stuff SDCCmem.c */
3216 doOverlays (ebbs, count);
3218 /* now get back the chain */
3219 ic = iCodeLabelOptimize (iCodeFromeBBlock (ebbs, count));
3223 /* free up any _G.stackSpil locations allocated */
3224 applyToSet (_G.stackSpil, deallocStackSpil);
3226 setToNull ((void *) &_G.stackSpil);
3227 setToNull ((void *) &_G.spiltSet);
3228 /* mark all registers as free */