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 */
688 if (!_G.blockSpil && (selectS = liveRangesWith (lrcs, notUsedInRemaining, ebp, ic)))
690 sym = leastUsedLR (selectS);
703 /* find live ranges with spillocation && not used as pointers */
704 if ((selectS = liveRangesWith (lrcs, hasSpilLocnoUptr, ebp, ic)))
707 sym = leastUsedLR (selectS);
708 /* mark this as allocation required */
709 sym->usl.spillLoc->allocreq++;
713 /* find live ranges with spillocation */
714 if ((selectS = liveRangesWith (lrcs, hasSpilLoc, ebp, ic)))
717 sym = leastUsedLR (selectS);
718 sym->usl.spillLoc->allocreq++;
722 /* couldn't find then we need to create a spil
723 location on the stack , for which one? the least
725 if ((selectS = liveRangesWith (lrcs, noSpilLoc, ebp, ic)))
728 /* return a created spil location */
729 sym = createStackSpil (leastUsedLR (selectS));
730 sym->usl.spillLoc->allocreq++;
734 /* this is an extreme situation we will spill
735 this one : happens very rarely but it does happen */
741 /*-----------------------------------------------------------------*/
742 /* spilSomething - spil some variable & mark registers as free */
743 /*-----------------------------------------------------------------*/
745 spilSomething (iCode * ic, eBBlock * ebp, symbol * forSym)
750 /* get something we can spil */
751 ssym = selectSpil (ic, ebp, forSym);
753 /* mark it as spilt */
754 ssym->isspilt = ssym->spillA = 1;
755 _G.spiltSet = bitVectSetBit (_G.spiltSet, ssym->key);
757 /* mark it as not register assigned &
758 take it away from the set */
759 bitVectUnSetBit (_G.regAssigned, ssym->key);
760 bitVectUnSetBit (_G.totRegAssigned, ssym->key);
762 /* mark the registers as free */
763 for (i = 0; i < ssym->nRegs; i++)
765 freeReg (ssym->regs[i]);
767 /* if spilt on stack then free up r0 & r1
768 if they could have been assigned to as gprs */
769 if (!ds390_ptrRegReq && isSpiltOnStack (ssym) && !options.stack10bit)
772 spillLRWithPtrReg (ssym);
775 /* if this was a block level spil then insert push & pop
776 at the start & end of block respectively */
779 iCode *nic = newiCode (IPUSH, operandFromSymbol (ssym), NULL);
780 /* add push to the start of the block */
781 addiCodeToeBBlock (ebp, nic, (ebp->sch->op == LABEL ?
782 ebp->sch->next : ebp->sch));
783 nic = newiCode (IPOP, operandFromSymbol (ssym), NULL);
784 /* add pop to the end of the block */
785 addiCodeToeBBlock (ebp, nic, NULL);
788 /* if spilt because not used in the remainder of the
789 block then add a push before this instruction and
790 a pop at the end of the block */
791 if (ssym->remainSpil)
794 iCode *nic = newiCode (IPUSH, operandFromSymbol (ssym), NULL);
795 /* add push just before this instruction */
796 addiCodeToeBBlock (ebp, nic, ic);
798 nic = newiCode (IPOP, operandFromSymbol (ssym), NULL);
799 /* add pop to the end of the block */
800 addiCodeToeBBlock (ebp, nic, NULL);
809 /*-----------------------------------------------------------------*/
810 /* getRegPtr - will try for PTR if not a GPR type if not spil */
811 /*-----------------------------------------------------------------*/
813 getRegPtr (iCode * ic, eBBlock * ebp, symbol * sym)
819 /* try for a ptr type */
820 if ((reg = allocReg (REG_PTR)))
823 /* try for gpr type */
824 if ((reg = allocReg (REG_GPR)))
827 /* we have to spil */
828 if (!spilSomething (ic, ebp, sym))
831 /* make sure partially assigned registers aren't reused */
832 for (j=0; j<=sym->nRegs; j++)
834 sym->regs[j]->isFree = 0;
836 /* this looks like an infinite loop but
837 in really selectSpil will abort */
841 /*-----------------------------------------------------------------*/
842 /* getRegGpr - will try for GPR if not spil */
843 /*-----------------------------------------------------------------*/
845 getRegGpr (iCode * ic, eBBlock * ebp, symbol * sym)
851 /* try for gpr type */
852 if ((reg = allocReg (REG_GPR)))
855 if (!ds390_ptrRegReq)
856 if ((reg = allocReg (REG_PTR)))
859 /* we have to spil */
860 if (!spilSomething (ic, ebp, sym))
863 /* make sure partially assigned registers aren't reused */
864 for (j=0; j<=sym->nRegs; j++)
866 sym->regs[j]->isFree = 0;
868 /* this looks like an infinite loop but
869 in really selectSpil will abort */
873 /*-----------------------------------------------------------------*/
874 /* getRegPtrNoSpil - get it cannot split */
875 /*-----------------------------------------------------------------*/
876 static regs *getRegPtrNoSpil()
880 /* try for a ptr type */
881 if ((reg = allocReg (REG_PTR)))
884 /* try for gpr type */
885 if ((reg = allocReg (REG_GPR)))
890 /* just to make the compiler happy */
894 /*-----------------------------------------------------------------*/
895 /* getRegGprNoSpil - get it cannot split */
896 /*-----------------------------------------------------------------*/
897 static regs *getRegGprNoSpil()
901 if ((reg = allocReg (REG_GPR)))
904 if (!ds390_ptrRegReq)
905 if ((reg = allocReg (REG_PTR)))
910 /* just to make the compiler happy */
914 /*-----------------------------------------------------------------*/
915 /* symHasReg - symbol has a given register */
916 /*-----------------------------------------------------------------*/
918 symHasReg (symbol * sym, regs * reg)
922 for (i = 0; i < sym->nRegs; i++)
923 if (sym->regs[i] == reg)
929 /*-----------------------------------------------------------------*/
930 /* deassignLRs - check the live to and if they have registers & are */
931 /* not spilt then free up the registers */
932 /*-----------------------------------------------------------------*/
934 deassignLRs (iCode * ic, eBBlock * ebp)
940 for (sym = hTabFirstItem (liveRanges, &k); sym;
941 sym = hTabNextItem (liveRanges, &k))
945 /* if it does not end here */
946 if (sym->liveTo > ic->seq)
949 /* if it was spilt on stack then we can
950 mark the stack spil location as free */
955 sym->usl.spillLoc->isFree = 1;
961 if (!bitVectBitValue (_G.regAssigned, sym->key))
964 /* special case check if this is an IFX &
965 the privious one was a pop and the
966 previous one was not spilt then keep track
968 if (ic->op == IFX && ic->prev &&
969 ic->prev->op == IPOP &&
970 !ic->prev->parmPush &&
971 !OP_SYMBOL (IC_LEFT (ic->prev))->isspilt)
972 psym = OP_SYMBOL (IC_LEFT (ic->prev));
978 bitVectUnSetBit (_G.regAssigned, sym->key);
980 /* if the result of this one needs registers
981 and does not have it then assign it right
983 if (IC_RESULT (ic) &&
984 !(SKIP_IC2 (ic) || /* not a special icode */
985 ic->op == JUMPTABLE ||
991 (result = OP_SYMBOL (IC_RESULT (ic))) && /* has a result */
992 result->liveTo > ic->seq && /* and will live beyond this */
993 result->liveTo <= ebp->lSeq && /* does not go beyond this block */
994 result->liveFrom == ic->seq && /* does not start before here */
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 /* unusedLRS - returns a bitVector of liveranges not used in 'ebp' */
1136 /*-----------------------------------------------------------------*/
1137 bitVect *unusedLRs (eBBlock *ebp)
1139 bitVect *ret = NULL;
1143 if (!ebp) return NULL;
1144 for (sym = hTabFirstItem(liveRanges,&key); sym ;
1145 sym = hTabNextItem(liveRanges,&key)) {
1147 if (notUsedInBlock(sym,ebp,NULL)) {
1148 ret = bitVectSetBit(ret,sym->key);
1155 /*-----------------------------------------------------------------*/
1156 /* deassignUnsedLRs - if this baisc block ends in a return then */
1157 /* deassign symbols not used in this block */
1158 /*-----------------------------------------------------------------*/
1159 bitVect *deassignUnsedLRs(eBBlock *ebp)
1161 bitVect *unused = NULL;
1164 switch (returnAtEnd(ebp)) {
1165 case 2: /* successor block ends in a return */
1166 unused = unusedLRs((eBBlock *) setFirstItem(ebp->succList));
1168 case 1: /* this block ends in a return */
1169 unused = bitVectIntersect(unused,unusedLRs(ebp));
1174 for (i = 0 ; i < unused->size ; i++ ) {
1177 if (bitVectBitValue(unused,i)) {
1179 /* if assigned to registers */
1180 if (bitVectBitValue(_G.regAssigned,i)) {
1184 sym = hTabItemWithKey(liveRanges,i);
1185 /* remove it from regassigned & mark the
1187 bitVectUnSetBit(_G.regAssigned,i);
1188 for (j = 0 ; j < sym->nRegs; j++)
1189 freeReg(sym->regs[j]);
1191 /* not assigned to registers : remove from set*/
1192 bitVectUnSetBit(unused,i);
1200 /*-----------------------------------------------------------------*/
1201 /* reassignUnusedLRs - put registers to unused Live ranges */
1202 /*-----------------------------------------------------------------*/
1203 void reassignUnusedLRs (bitVect *unused)
1206 if (!unused) return ;
1208 for (i = 0 ; i < unused->size ; i++ ) {
1209 /* if unused : means it was assigned to registers before */
1210 if (bitVectBitValue(unused,i)) {
1214 /* put it back into reg set*/
1215 bitVectSetBit(_G.regAssigned,i) ;
1217 sym = hTabItemWithKey(liveRanges,i);
1218 /* makr registers busy */
1219 for (j = 0 ; j < sym->nRegs; j++)
1220 sym->regs[j]->isFree = 0;
1225 /*------------------------------------------------------------------*/
1226 /* verifyRegsAssigned - make sure an iTemp is properly initialized; */
1227 /* it should either have registers or have beed spilled. Otherwise, */
1228 /* there was an uninitialized variable, so just spill this to get */
1229 /* the operand in a valid state. */
1230 /*------------------------------------------------------------------*/
1232 verifyRegsAssigned (operand *op, iCode * ic)
1237 if (!IS_ITEMP (op)) return;
1239 sym = OP_SYMBOL (op);
1240 if (sym->isspilt) return;
1241 if (!sym->nRegs) return;
1242 if (sym->regs[0]) return;
1244 werrorfl (ic->filename, ic->lineno, W_LOCAL_NOINIT,
1245 sym->prereqv ? sym->prereqv->name : sym->name);
1250 /*-----------------------------------------------------------------*/
1251 /* serialRegAssign - serially allocate registers to the variables */
1252 /*-----------------------------------------------------------------*/
1254 serialRegAssign (eBBlock ** ebbs, int count)
1258 /* for all blocks */
1259 for (i = 0; i < count; i++)
1263 bitVect *unusedLRs = NULL;
1265 if (ebbs[i]->noPath &&
1266 (ebbs[i]->entryLabel != entryLabel &&
1267 ebbs[i]->entryLabel != returnLabel))
1270 unusedLRs = deassignUnsedLRs(ebbs[i]);
1272 /* of all instructions do */
1273 for (ic = ebbs[i]->sch; ic; ic = ic->next)
1276 /* if this is an ipop that means some live
1277 range will have to be assigned again */
1279 reassignLR (IC_LEFT (ic));
1281 /* if result is present && is a true symbol */
1282 if (IC_RESULT (ic) && ic->op != IFX &&
1283 IS_TRUE_SYMOP (IC_RESULT (ic)))
1284 OP_SYMBOL (IC_RESULT (ic))->allocreq++;
1286 /* take away registers from live
1287 ranges that end at this instruction */
1288 deassignLRs (ic, ebbs[i]);
1290 /* some don't need registers */
1291 if (SKIP_IC2 (ic) ||
1292 ic->op == JUMPTABLE ||
1296 (IC_RESULT (ic) && POINTER_SET (ic)))
1299 /* now we need to allocate registers
1300 only for the result */
1303 symbol *sym = OP_SYMBOL (IC_RESULT (ic));
1309 /* if it does not need or is spilt
1310 or is already assigned to registers
1311 or will not live beyond this instructions */
1314 bitVectBitValue (_G.regAssigned, sym->key) ||
1315 sym->liveTo <= ic->seq)
1318 /* if some liverange has been spilt at the block level
1319 and this one live beyond this block then spil this
1321 if (_G.blockSpil && sym->liveTo > ebbs[i]->lSeq)
1326 /* if trying to allocate this will cause
1327 a spill and there is nothing to spill
1328 or this one is rematerializable then
1330 willCS = willCauseSpill (sym->nRegs, sym->regType);
1331 spillable = computeSpillable (ic);
1333 (willCS && bitVectIsZero (spillable)))
1341 /* If the live range preceeds the point of definition
1342 then ideally we must take into account registers that
1343 have been allocated after sym->liveFrom but freed
1344 before ic->seq. This is complicated, so spill this
1345 symbol instead and let fillGaps handle the allocation. */
1346 if (sym->liveFrom < ic->seq)
1352 /* if it has a spillocation & is used less than
1353 all other live ranges then spill this */
1355 if (sym->usl.spillLoc) {
1356 symbol *leastUsed = leastUsedLR (liveRangesWith (spillable,
1357 allLRs, ebbs[i], ic));
1358 if (leastUsed && leastUsed->used > sym->used) {
1363 /* if none of the liveRanges have a spillLocation then better
1364 to spill this one than anything else already assigned to registers */
1365 if (liveRangesWith(spillable,noSpilLoc,ebbs[i],ic)) {
1366 /* if this is local to this block then we might find a block spil */
1367 if (!(sym->liveFrom >= ebbs[i]->fSeq && sym->liveTo <= ebbs[i]->lSeq)) {
1375 /* if we need ptr regs for the right side
1377 if (POINTER_GET (ic) && IS_SYMOP (IC_LEFT (ic))
1378 && getSize (OP_SYMBOL (IC_LEFT (ic))->type)
1379 <= (unsigned) PTRSIZE)
1384 /* else we assign registers to it */
1385 _G.regAssigned = bitVectSetBit (_G.regAssigned, sym->key);
1386 _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, sym->key);
1388 for (j = 0; j < sym->nRegs; j++)
1390 if (sym->regType == REG_PTR)
1391 sym->regs[j] = getRegPtr (ic, ebbs[i], sym);
1393 sym->regs[j] = getRegGpr (ic, ebbs[i], sym);
1395 /* if the allocation falied which means
1396 this was spilt then break */
1401 /* if it shares registers with operands make sure
1402 that they are in the same position */
1403 if (!POINTER_SET(ic) && !POINTER_GET(ic))
1405 if (IC_LEFT (ic) && IS_SYMOP (IC_LEFT (ic)) &&
1406 OP_SYMBOL (IC_LEFT (ic))->nRegs)
1408 positionRegs (OP_SYMBOL (IC_RESULT (ic)),
1409 OP_SYMBOL (IC_LEFT (ic)));
1411 /* do the same for the right operand */
1412 if (IC_RIGHT (ic) && IS_SYMOP (IC_RIGHT (ic)) &&
1413 OP_SYMBOL (IC_RIGHT (ic))->nRegs)
1415 positionRegs (OP_SYMBOL (IC_RESULT (ic)),
1416 OP_SYMBOL (IC_RIGHT (ic)));
1428 reassignUnusedLRs(unusedLRs);
1431 /* Check for and fix any problems with uninitialized operands */
1432 for (i = 0; i < count; i++)
1436 if (ebbs[i]->noPath &&
1437 (ebbs[i]->entryLabel != entryLabel &&
1438 ebbs[i]->entryLabel != returnLabel))
1441 for (ic = ebbs[i]->sch; ic; ic = ic->next)
1448 verifyRegsAssigned (IC_COND (ic), ic);
1452 if (ic->op == JUMPTABLE)
1454 verifyRegsAssigned (IC_JTCOND (ic), ic);
1458 verifyRegsAssigned (IC_RESULT (ic), ic);
1459 verifyRegsAssigned (IC_LEFT (ic), ic);
1460 verifyRegsAssigned (IC_RIGHT (ic), ic);
1465 /*-----------------------------------------------------------------*/
1466 /* fillGaps - Try to fill in the Gaps left by Pass1 */
1467 /*-----------------------------------------------------------------*/
1468 static void fillGaps()
1472 int loop = 0, change;
1475 if (getenv("DISABLE_FILL_GAPS")) return;
1477 /* First try to do DPTRuse once more since now we know what got into
1480 while (loop++ < 10) {
1483 for (sym = hTabFirstItem(liveRanges,&key) ; sym ;
1484 sym = hTabNextItem(liveRanges,&key)) {
1485 int size = getSize(sym->type);
1487 if (sym->liveFrom == sym->liveTo) continue;
1489 if (sym->uptr && sym->dptr==0 && !sym->ruonly &&
1490 size < 4 && size > 1) {
1492 if (packRegsDPTRuse(operandFromSymbol(sym))) {
1494 /* if this was assigned to registers then */
1495 if (bitVectBitValue(_G.totRegAssigned,sym->key)) {
1496 /* take it out of the register assigned set */
1497 bitVectUnSetBit(_G.totRegAssigned,sym->key);
1498 } else if (sym->usl.spillLoc) {
1499 sym->usl.spillLoc->allocreq--;
1500 sym->usl.spillLoc = NULL;
1504 sym->isspilt = sym->spillA = 0;
1508 /* try assigning other dptrs */
1509 if (sym->dptr == 0 && packRegsDPTRnuse(operandFromSymbol(sym),1) && !getenv("DPTRnDISABLE")) {
1510 /* if this was ssigned to registers then */
1511 if (bitVectBitValue(_G.totRegAssigned,sym->key)) {
1512 /* take it out of the register assigned set */
1513 bitVectUnSetBit(_G.totRegAssigned,sym->key);
1514 } else if (sym->usl.spillLoc) {
1515 sym->usl.spillLoc->allocreq--;
1516 sym->usl.spillLoc = NULL;
1519 sym->isspilt = sym->spillA = 0;
1524 /* look for livernages that was spilt by the allocator */
1525 for (sym = hTabFirstItem(liveRanges,&key) ; sym ;
1526 sym = hTabNextItem(liveRanges,&key)) {
1531 if (!sym->spillA || !sym->clashes || sym->remat) continue ;
1532 if (!sym->uses || !sym->defs) continue ;
1533 /* find the liveRanges this one clashes with, that are
1534 still assigned to registers & mark the registers as used*/
1535 for ( i = 0 ; i < sym->clashes->size ; i ++) {
1539 if (bitVectBitValue(sym->clashes,i) == 0 || /* those that clash with this */
1540 bitVectBitValue(_G.totRegAssigned,i) == 0) /* and are still assigned to registers */
1543 clr = hTabItemWithKey(liveRanges,i);
1546 /* mark these registers as used */
1547 for (k = 0 ; k < clr->nRegs ; k++ )
1548 useReg(clr->regs[k]);
1551 if (willCauseSpill(sym->nRegs,sym->regType)) {
1552 /* NOPE :( clear all registers & and continue */
1557 /* THERE IS HOPE !!!! */
1558 for (i=0; i < sym->nRegs ; i++ ) {
1559 if (sym->regType == REG_PTR)
1560 sym->regs[i] = getRegPtrNoSpil ();
1562 sym->regs[i] = getRegGprNoSpil ();
1565 /* For all its definitions check if the registers
1566 allocated needs positioning NOTE: we can position
1567 only ONCE if more than One positioning required
1569 We may need to perform the checks twice; once to
1570 position the registers as needed, the second to
1571 verify any register repositioning is still
1575 for (pass=0; pass<2; pass++) {
1576 for (i = 0 ; i < sym->defs->size ; i++ ) {
1577 if (bitVectBitValue(sym->defs,i)) {
1579 if (!(ic = hTabItemWithKey(iCodehTab,i))) continue ;
1580 if (SKIP_IC(ic)) continue;
1581 assert(isSymbolEqual(sym,OP_SYMBOL(IC_RESULT(ic)))); /* just making sure */
1582 /* if left is assigned to registers */
1583 if (IS_SYMOP(IC_LEFT(ic)) &&
1584 bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_LEFT(ic))->key)) {
1585 pdone += (positionRegs(sym,OP_SYMBOL(IC_LEFT(ic)))>0);
1587 if (IS_SYMOP(IC_RIGHT(ic)) &&
1588 bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_RIGHT(ic))->key)) {
1589 pdone += (positionRegs(sym,OP_SYMBOL(IC_RIGHT(ic)))>0);
1591 if (pdone > 1) break;
1594 for (i = 0 ; i < sym->uses->size ; i++ ) {
1595 if (bitVectBitValue(sym->uses,i)) {
1597 if (!(ic = hTabItemWithKey(iCodehTab,i))) continue ;
1598 if (SKIP_IC(ic)) continue;
1599 if (POINTER_SET(ic) || POINTER_GET(ic)) continue ;
1601 /* if result is assigned to registers */
1602 if (IS_SYMOP(IC_RESULT(ic)) &&
1603 bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_RESULT(ic))->key)) {
1604 pdone += (positionRegs(sym,OP_SYMBOL(IC_RESULT(ic)))>0);
1606 if (pdone > 1) break;
1609 if (pdone == 0) break; /* second pass only if regs repositioned */
1610 if (pdone > 1) break;
1612 /* had to position more than once GIVE UP */
1614 /* UNDO all the changes we made to try this */
1616 for (i=0; i < sym->nRegs ; i++ ) {
1617 sym->regs[i] = NULL;
1620 D (fprintf (stderr, "Fill Gap gave up due to positioning for "
1621 "%s in function %s\n",
1622 sym->name, currFunc ? currFunc->name : "UNKNOWN"));
1625 D (fprintf (stderr, "FILLED GAP for %s in function %s\n",
1626 sym->name, currFunc ? currFunc->name : "UNKNOWN"));
1627 _G.totRegAssigned = bitVectSetBit(_G.totRegAssigned,sym->key);
1628 sym->isspilt = sym->spillA = 0 ;
1629 sym->usl.spillLoc->allocreq--;
1630 sym->usl.spillLoc = NULL;
1638 /*-----------------------------------------------------------------*/
1639 /* rUmaskForOp :- returns register mask for an operand */
1640 /*-----------------------------------------------------------------*/
1642 ds390_rUmaskForOp (operand * op)
1648 /* only temporaries are assigned registers */
1652 sym = OP_SYMBOL (op);
1654 /* if spilt or no registers assigned to it
1656 if (sym->isspilt || !sym->nRegs)
1659 rumask = newBitVect (ds390_nRegs);
1661 for (j = 0; j < sym->nRegs; j++)
1663 rumask = bitVectSetBit (rumask,
1664 sym->regs[j]->rIdx);
1670 /*-----------------------------------------------------------------*/
1671 /* regsUsedIniCode :- returns bit vector of registers used in iCode */
1672 /*-----------------------------------------------------------------*/
1674 regsUsedIniCode (iCode * ic)
1676 bitVect *rmask = newBitVect (ds390_nRegs);
1678 /* do the special cases first */
1681 rmask = bitVectUnion (rmask,
1682 ds390_rUmaskForOp (IC_COND (ic)));
1686 /* for the jumptable */
1687 if (ic->op == JUMPTABLE)
1689 rmask = bitVectUnion (rmask,
1690 ds390_rUmaskForOp (IC_JTCOND (ic)));
1695 /* of all other cases */
1697 rmask = bitVectUnion (rmask,
1698 ds390_rUmaskForOp (IC_LEFT (ic)));
1702 rmask = bitVectUnion (rmask,
1703 ds390_rUmaskForOp (IC_RIGHT (ic)));
1706 rmask = bitVectUnion (rmask,
1707 ds390_rUmaskForOp (IC_RESULT (ic)));
1713 /*-----------------------------------------------------------------*/
1714 /* createRegMask - for each instruction will determine the regsUsed */
1715 /*-----------------------------------------------------------------*/
1717 createRegMask (eBBlock ** ebbs, int count)
1721 /* for all blocks */
1722 for (i = 0; i < count; i++)
1726 if (ebbs[i]->noPath &&
1727 (ebbs[i]->entryLabel != entryLabel &&
1728 ebbs[i]->entryLabel != returnLabel))
1731 /* for all instructions */
1732 for (ic = ebbs[i]->sch; ic; ic = ic->next)
1737 if (SKIP_IC2 (ic) || !ic->rlive)
1740 /* first mark the registers used in this
1742 ic->rUsed = regsUsedIniCode (ic);
1743 _G.funcrUsed = bitVectUnion (_G.funcrUsed, ic->rUsed);
1745 /* now create the register mask for those
1746 registers that are in use : this is a
1747 super set of ic->rUsed */
1748 ic->rMask = newBitVect (ds390_nRegs + 1);
1750 /* for all live Ranges alive at this point */
1751 for (j = 1; j < ic->rlive->size; j++)
1756 /* if not alive then continue */
1757 if (!bitVectBitValue (ic->rlive, j))
1760 /* find the live range we are interested in */
1761 if (!(sym = hTabItemWithKey (liveRanges, j)))
1763 werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
1764 "createRegMask cannot find live range");
1765 fprintf(stderr, "\tmissing live range: key=%d\n", j);
1769 /* special case for ruonly */
1770 if (sym->ruonly && sym->liveFrom != sym->liveTo) {
1771 int size = getSize(sym->type);
1773 for (k = 0 ; k < size; k++ )
1774 ic->rMask = bitVectSetBit (ic->rMask, j++);
1778 /* if no register assigned to it */
1779 if (!sym->nRegs || sym->isspilt)
1782 /* for all the registers allocated to it */
1783 for (k = 0; k < sym->nRegs; k++)
1786 bitVectSetBit (ic->rMask, sym->regs[k]->rIdx);
1792 /*-----------------------------------------------------------------*/
1793 /* rematStr - returns the rematerialized string for a remat var */
1794 /*-----------------------------------------------------------------*/
1796 rematStr (symbol * sym)
1799 iCode *ic = sym->rematiCode;
1806 /* if plus or minus print the right hand side */
1807 if (ic->op == '+' || ic->op == '-')
1809 SNPRINTF (s, sizeof(buffer) - strlen(buffer),
1810 "0x%04x %c ", (int) operandLitValue (IC_RIGHT (ic)),
1813 ic = OP_SYMBOL (IC_LEFT (ic))->rematiCode;
1817 /* cast then continue */
1818 if (IS_CAST_ICODE(ic)) {
1819 ic = OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
1822 /* we reached the end */
1823 SNPRINTF (s, sizeof(buffer) - strlen(buffer),
1824 "%s", OP_SYMBOL (IC_LEFT (ic))->rname);
1831 /*-----------------------------------------------------------------*/
1832 /* regTypeNum - computes the type & number of registers required */
1833 /*-----------------------------------------------------------------*/
1841 /* for each live range do */
1842 for (sym = hTabFirstItem (liveRanges, &k); sym;
1843 sym = hTabNextItem (liveRanges, &k))
1846 /* if used zero times then no registers needed */
1847 if ((sym->liveTo - sym->liveFrom) == 0)
1851 /* if the live range is a temporary */
1855 /* if the type is marked as a conditional */
1856 if (sym->regType == REG_CND)
1859 /* if used in return only then we don't
1861 if (sym->ruonly || sym->accuse)
1863 if (IS_AGGREGATE (sym->type) || sym->isptr)
1864 sym->type = aggrToPtr (sym->type, FALSE);
1868 /* if the symbol has only one definition &
1869 that definition is a get_pointer */
1870 if (bitVectnBitsOn (sym->defs) == 1 &&
1871 (ic = hTabItemWithKey (iCodehTab,
1872 bitVectFirstBit (sym->defs))) &&
1874 !IS_BITVAR (sym->etype) &&
1875 (aggrToPtrDclType (operandType (IC_LEFT (ic)), FALSE) == POINTER))
1878 if (ptrPseudoSymSafe (sym, ic))
1880 ptrPseudoSymConvert (sym, ic, rematStr (OP_SYMBOL (IC_LEFT (ic))));
1884 /* if in data space or idata space then try to
1885 allocate pointer register */
1889 /* if not then we require registers */
1890 sym->nRegs = ((IS_AGGREGATE (sym->type) || sym->isptr) ?
1891 getSize (sym->type = aggrToPtr (sym->type, FALSE)) :
1892 getSize (sym->type));
1896 fprintf (stderr, "allocated more than 4 or 0 registers for type ");
1897 printTypeChain (sym->type, stderr);
1898 fprintf (stderr, "\n");
1901 /* determine the type of register required */
1902 if (sym->nRegs == 1 &&
1903 IS_PTR (sym->type) &&
1905 sym->regType = REG_PTR;
1907 sym->regType = REG_GPR;
1911 /* for the first run we don't provide */
1912 /* registers for true symbols we will */
1913 /* see how things go */
1919 /*-----------------------------------------------------------------*/
1920 /* freeAllRegs - mark all registers as free */
1921 /*-----------------------------------------------------------------*/
1927 for (i = 0; i < ds390_nRegs; i++)
1928 regs390[i].isFree = 1;
1931 /*-----------------------------------------------------------------*/
1932 /* deallocStackSpil - this will set the stack pointer back */
1933 /*-----------------------------------------------------------------*/
1935 DEFSETFUNC (deallocStackSpil)
1943 /*-----------------------------------------------------------------*/
1944 /* farSpacePackable - returns the packable icode for far variables */
1945 /*-----------------------------------------------------------------*/
1947 farSpacePackable (iCode * ic)
1951 /* go thru till we find a definition for the
1952 symbol on the right */
1953 for (dic = ic->prev; dic; dic = dic->prev)
1955 /* if the definition is a call then no */
1956 if ((dic->op == CALL || dic->op == PCALL) &&
1957 IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
1962 /* if shift by unknown amount then not */
1963 if ((dic->op == LEFT_OP || dic->op == RIGHT_OP) &&
1964 IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
1967 /* if pointer get and size > 1 */
1968 if (POINTER_GET (dic) &&
1969 getSize (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)) > 1)
1972 if (POINTER_SET (dic) &&
1973 getSize (aggrToPtr (operandType (IC_RESULT (dic)), FALSE)) > 1)
1976 /* if any tree is a true symbol in far space */
1977 if (IC_RESULT (dic) &&
1978 IS_TRUE_SYMOP (IC_RESULT (dic)) &&
1979 isOperandInFarSpace (IC_RESULT (dic)))
1982 if (IC_RIGHT (dic) &&
1983 IS_TRUE_SYMOP (IC_RIGHT (dic)) &&
1984 isOperandInFarSpace (IC_RIGHT (dic)) &&
1985 !isOperandEqual (IC_RIGHT (dic), IC_RESULT (ic)))
1988 if (IC_LEFT (dic) &&
1989 IS_TRUE_SYMOP (IC_LEFT (dic)) &&
1990 isOperandInFarSpace (IC_LEFT (dic)) &&
1991 !isOperandEqual (IC_LEFT (dic), IC_RESULT (ic)))
1994 if (isOperandEqual (IC_RIGHT (ic), IC_RESULT (dic)))
1996 if ((dic->op == LEFT_OP ||
1997 dic->op == RIGHT_OP ||
1999 IS_OP_LITERAL (IC_RIGHT (dic)))
2009 /*-----------------------------------------------------------------*/
2010 /* packRegsForAssign - register reduction for assignment */
2011 /*-----------------------------------------------------------------*/
2013 packRegsForAssign (iCode * ic, eBBlock * ebp)
2017 if (!IS_ITEMP (IC_RIGHT (ic)) ||
2018 OP_SYMBOL (IC_RIGHT (ic))->isind ||
2019 OP_LIVETO (IC_RIGHT (ic)) > ic->seq)
2024 /* if the true symbol is defined in far space or on stack
2025 then we should not since this will increase register pressure */
2027 if (isOperandInFarSpace (IC_RESULT (ic)))
2029 if ((dic = farSpacePackable (ic)))
2035 if (isOperandInFarSpace(IC_RESULT(ic)) && !farSpacePackable(ic)) {
2040 /* find the definition of iTempNN scanning backwards if we find a
2041 a use of the true symbol in before we find the definition then
2043 for (dic = ic->prev; dic; dic = dic->prev)
2045 /* if there is a function call then don't pack it */
2046 if ((dic->op == CALL || dic->op == PCALL))
2055 if (IS_TRUE_SYMOP (IC_RESULT (dic)) &&
2056 IS_OP_VOLATILE (IC_RESULT (dic)))
2062 if (IS_SYMOP (IC_RESULT (dic)) &&
2063 IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
2065 if (POINTER_SET (dic))
2071 if (IS_SYMOP (IC_RIGHT (dic)) &&
2072 (IC_RIGHT (dic)->key == IC_RESULT (ic)->key ||
2073 IC_RIGHT (dic)->key == IC_RIGHT (ic)->key))
2079 if (IS_SYMOP (IC_LEFT (dic)) &&
2080 (IC_LEFT (dic)->key == IC_RESULT (ic)->key ||
2081 IC_LEFT (dic)->key == IC_RIGHT (ic)->key))
2087 if (POINTER_SET (dic) &&
2088 IC_RESULT (dic)->key == IC_RESULT (ic)->key)
2096 return 0; /* did not find */
2098 /* if the result is on stack or iaccess then it must be
2099 the same atleast one of the operands */
2100 if (OP_SYMBOL (IC_RESULT (ic))->onStack ||
2101 OP_SYMBOL (IC_RESULT (ic))->iaccess)
2104 /* the operation has only one symbol
2105 operator then we can pack */
2106 if ((IC_LEFT (dic) && !IS_SYMOP (IC_LEFT (dic))) ||
2107 (IC_RIGHT (dic) && !IS_SYMOP (IC_RIGHT (dic))))
2110 if (!((IC_LEFT (dic) &&
2111 IC_RESULT (ic)->key == IC_LEFT (dic)->key) ||
2113 IC_RESULT (ic)->key == IC_RIGHT (dic)->key)))
2117 /* found the definition */
2118 /* replace the result with the result of */
2119 /* this assignment and remove this assignment */
2120 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2122 IC_RESULT (dic) = IC_RESULT (ic);
2124 if (IS_ITEMP (IC_RESULT (dic)) && OP_SYMBOL (IC_RESULT (dic))->liveFrom > dic->seq)
2126 OP_SYMBOL (IC_RESULT (dic))->liveFrom = dic->seq;
2128 /* delete from liverange table also
2129 delete from all the points inbetween and the new
2131 for (sic = dic; sic != ic; sic = sic->next)
2133 bitVectUnSetBit (sic->rlive, IC_RESULT (ic)->key);
2134 if (IS_ITEMP (IC_RESULT (dic)))
2135 bitVectSetBit (sic->rlive, IC_RESULT (dic)->key);
2138 remiCodeFromeBBlock (ebp, ic);
2139 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
2140 hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
2141 OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
2145 /*------------------------------------------------------------------*/
2146 /* findAssignToSym : scanning backwards looks for first assig found */
2147 /*------------------------------------------------------------------*/
2149 findAssignToSym (operand * op, iCode * ic)
2153 /* This routine is used to find sequences like
2155 ...; (intervening ops don't use iTempAA or modify FOO)
2156 blah = blah + iTempAA;
2158 and eliminate the use of iTempAA, freeing up its register for
2162 for (dic = ic->prev; dic; dic = dic->prev)
2165 /* if definition by assignment */
2166 if (dic->op == '=' &&
2167 !POINTER_SET (dic) &&
2168 IC_RESULT (dic)->key == op->key
2169 /* && IS_TRUE_SYMOP(IC_RIGHT(dic)) */
2173 /* we are interested only if defined in far space */
2174 /* or in stack space in case of + & - */
2176 /* if assigned to a non-symbol then return
2178 if (!IS_SYMOP (IC_RIGHT (dic)))
2181 /* if the symbol is in far space then
2183 if (isOperandInFarSpace (IC_RIGHT (dic)))
2186 /* for + & - operations make sure that
2187 if it is on the stack it is the same
2188 as one of the three operands */
2189 if ((ic->op == '+' || ic->op == '-') &&
2190 OP_SYMBOL (IC_RIGHT (dic))->onStack)
2193 if (IC_RESULT (ic)->key != IC_RIGHT (dic)->key &&
2194 IC_LEFT (ic)->key != IC_RIGHT (dic)->key &&
2195 IC_RIGHT (ic)->key != IC_RIGHT (dic)->key)
2203 /* if we find an usage then we cannot delete it */
2204 if (IC_LEFT (dic) && IC_LEFT (dic)->key == op->key)
2207 if (IC_RIGHT (dic) && IC_RIGHT (dic)->key == op->key)
2210 if (POINTER_SET (dic) && IC_RESULT (dic)->key == op->key)
2214 /* now make sure that the right side of dic
2215 is not defined between ic & dic */
2218 iCode *sic = dic->next;
2220 for (; sic != ic; sic = sic->next)
2221 if (IC_RESULT (sic) &&
2222 IC_RESULT (sic)->key == IC_RIGHT (dic)->key)
2231 /*-----------------------------------------------------------------*/
2232 /* packRegsForSupport :- reduce some registers for support calls */
2233 /*-----------------------------------------------------------------*/
2235 packRegsForSupport (iCode * ic, eBBlock * ebp)
2239 /* for the left & right operand :- look to see if the
2240 left was assigned a true symbol in far space in that
2241 case replace them */
2242 if (IS_ITEMP (IC_LEFT (ic)) &&
2243 OP_SYMBOL (IC_LEFT (ic))->liveTo <= ic->seq)
2245 iCode *dic = findAssignToSym (IC_LEFT (ic), ic);
2251 /* found it we need to remove it from the
2253 for (sic = dic; sic != ic; sic = sic->next) {
2254 bitVectUnSetBit (sic->rlive, IC_LEFT (ic)->key);
2255 sic->rlive = bitVectSetBit (sic->rlive, IC_RIGHT (dic)->key);
2258 wassert(IS_SYMOP(IC_LEFT (ic)));
2259 wassert(IS_SYMOP(IC_RIGHT (dic)));
2260 IC_LEFT (ic)->operand.symOperand =
2261 IC_RIGHT (dic)->operand.symOperand;
2262 OP_SYMBOL(IC_LEFT(ic))->liveTo = ic->seq;
2263 IC_LEFT (ic)->key = IC_RIGHT (dic)->operand.symOperand->key;
2264 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2265 remiCodeFromeBBlock (ebp, dic);
2266 hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2270 /* do the same for the right operand */
2273 IS_ITEMP (IC_RIGHT (ic)) &&
2274 OP_SYMBOL (IC_RIGHT (ic))->liveTo <= ic->seq)
2276 iCode *dic = findAssignToSym (IC_RIGHT (ic), ic);
2282 /* if this is a subtraction & the result
2283 is a true symbol in far space then don't pack */
2284 if (ic->op == '-' && IS_TRUE_SYMOP (IC_RESULT (dic)))
2286 sym_link *etype = getSpec (operandType (IC_RESULT (dic)));
2287 if (IN_FARSPACE (SPEC_OCLS (etype)))
2290 /* found it we need to remove it from the
2292 for (sic = dic; sic != ic; sic = sic->next) {
2293 bitVectUnSetBit (sic->rlive, IC_RIGHT (ic)->key);
2294 sic->rlive = bitVectSetBit (sic->rlive, IC_RIGHT (dic)->key);
2297 wassert(IS_SYMOP(IC_RIGHT (ic)));
2298 wassert(IS_SYMOP(IC_RIGHT (dic)));
2299 IC_RIGHT (ic)->operand.symOperand =
2300 IC_RIGHT (dic)->operand.symOperand;
2301 IC_RIGHT (ic)->key = IC_RIGHT (dic)->operand.symOperand->key;
2302 OP_SYMBOL(IC_RIGHT(ic))->liveTo = ic->seq;
2303 remiCodeFromeBBlock (ebp, dic);
2304 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2305 hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2312 #define IS_OP_RUONLY(x) (x && IS_SYMOP(x) && OP_SYMBOL(x)->ruonly)
2315 /*-----------------------------------------------------------------*/
2316 /* packRegsDPTRnuse - color live ranges that can go into extra DPTRS */
2317 /*-----------------------------------------------------------------*/
2318 static int packRegsDPTRnuse( operand *op , unsigned dptr)
2323 if (!IS_SYMOP(op) || !IS_ITEMP(op)) return 0;
2324 if (OP_SYMBOL(op)->remat || OP_SYMBOL(op)->ruonly || OP_SYMBOL(op)->dptr)
2327 /* first check if any overlapping liverange has already been
2328 assigned to this DPTR */
2329 if (OP_SYMBOL(op)->clashes) {
2330 for (i = 0 ; i < OP_SYMBOL(op)->clashes->size ; i++ ) {
2332 if (bitVectBitValue(OP_SYMBOL(op)->clashes,i)) {
2333 sym = hTabItemWithKey(liveRanges,i);
2334 if (sym->dptr == dptr) return 0;
2339 /* future for more dptrs */
2341 OP_SYMBOL(op)->dptr = dptr;
2345 /* DPTR1 is special since it is also used as a scratch by the backend .
2346 so we walk thru the entire live range of this operand and make sure
2347 DPTR1 will not be used by the backed . The logic here is to find out if
2348 more than one operand in an icode is in far space then we give up : we
2349 don't keep it live across functions for now
2352 ic = hTabFirstItemWK(iCodeSeqhTab,OP_SYMBOL(op)->liveFrom);
2353 for (; ic && ic->seq <= OP_SYMBOL(op)->liveTo;
2354 ic = hTabNextItem(iCodeSeqhTab,&key)) {
2357 if (ic->op == CALL || ic->op == PCALL) return 0;
2359 /* single operand icode are ok */
2360 if (ic->op == IFX || ic->op == IPUSH)
2363 if (ic->op == SEND ) {
2364 if (ic->argreg != 1 ) return 0;
2367 /* two special cases first */
2368 if (POINTER_GET(ic) && !isOperandEqual(IC_LEFT(ic),op) && /* pointer get */
2369 !OP_SYMBOL(IC_LEFT(ic))->ruonly && /* with result in far space */
2370 (isOperandInFarSpace(IC_RESULT(ic)) &&
2371 !isOperandInReg(IC_RESULT(ic)))) {
2375 if (POINTER_SET(ic) && !isOperandEqual(IC_RESULT(ic),op) && /* pointer set */
2376 !OP_SYMBOL(IC_RESULT(ic))->ruonly && /* with right in far space */
2377 (isOperandInFarSpace(IC_RIGHT(ic)) &&
2378 !isOperandInReg(IC_RIGHT(ic)))) {
2382 if (IC_RESULT(ic) && IS_SYMOP(IC_RESULT(ic)) && /* if symbol operand */
2383 !isOperandEqual(IC_RESULT(ic),op) && /* not the same as this */
2384 ((isOperandInFarSpace(IC_RESULT(ic)) || /* in farspace or */
2385 OP_SYMBOL(IC_RESULT(ic))->onStack) && /* on the stack */
2386 !isOperandInReg(IC_RESULT(ic)))) { /* and not in register */
2390 if (IC_LEFT(ic) && IS_SYMOP(IC_LEFT(ic)) && /* if symbol operand */
2391 !isOperandEqual(IC_LEFT(ic),op) && /* not the same as this */
2392 ((isOperandInFarSpace(IC_LEFT(ic)) || /* in farspace or */
2393 OP_SYMBOL(IC_LEFT(ic))->onStack) && /* on the stack */
2394 !isOperandInReg(IC_LEFT(ic)))) { /* and not in register */
2397 /* same for right */
2398 if (IC_RIGHT(ic) && IS_SYMOP(IC_RIGHT(ic)) && /* if symbol operand */
2399 !isOperandEqual(IC_RIGHT(ic),op) && /* not the same as this */
2400 ((isOperandInFarSpace(IC_RIGHT(ic)) || /* in farspace or */
2401 OP_SYMBOL(IC_RIGHT(ic))->onStack) && /* on the stack */
2402 !isOperandInReg(IC_RIGHT(ic)))) { /* and not in register */
2406 // Check that no other ops in this range have been assigned to dptr1.
2407 // I don't understand why this is not caught by the first check, above.
2408 // But it isn't always, see bug 769624.
2409 if (IC_RESULT(ic) && IS_SYMOP(IC_RESULT(ic)) &&
2410 (OP_SYMBOL(IC_RESULT(ic))->dptr == 1))
2412 //fprintf(stderr, "dptr1 already in use in live range #1\n");
2416 if (IC_LEFT(ic) && IS_SYMOP(IC_LEFT(ic)) &&
2417 (OP_SYMBOL(IC_LEFT(ic))->dptr == 1))
2419 //fprintf(stderr, "dptr1 already in use in live range # 2\n");
2423 if (IC_RIGHT(ic) && IS_SYMOP(IC_RIGHT(ic)) &&
2424 (OP_SYMBOL(IC_RIGHT(ic))->dptr == 1))
2426 //fprintf(stderr, "dptr1 already in use in live range # 3\n");
2430 if (nfs && IC_RESULT(ic) && IS_SYMOP(IC_RESULT(ic)) &&
2431 OP_SYMBOL(IC_RESULT(ic))->ruonly) return 0;
2433 if (nfs > 1) return 0;
2435 OP_SYMBOL(op)->dptr = dptr;
2439 /*-----------------------------------------------------------------*/
2440 /* packRegsDPTRuse : - will reduce some registers for single Use */
2441 /*-----------------------------------------------------------------*/
2443 packRegsDPTRuse (operand * op)
2445 /* go thru entire liveRange of this variable & check for
2446 other possible usage of DPTR , if we don't find it the
2447 assign this to DPTR (ruonly)
2452 sym_link *type, *etype;
2454 if (!IS_SYMOP(op) || !IS_ITEMP(op)) return NULL;
2455 if (OP_SYMBOL(op)->remat || OP_SYMBOL(op)->ruonly) return NULL;
2457 /* first check if any overlapping liverange has already been
2459 if (OP_SYMBOL(op)->clashes) {
2460 for (i = 0 ; i < OP_SYMBOL(op)->clashes->size ; i++ ) {
2461 if (bitVectBitValue(OP_SYMBOL(op)->clashes,i)) {
2462 sym = hTabItemWithKey(liveRanges,i);
2463 if (sym->ruonly) return NULL ;
2468 /* no then go thru this guys live range */
2469 dic = ic = hTabFirstItemWK(iCodeSeqhTab,OP_SYMBOL(op)->liveFrom);
2470 for (; ic && ic->seq <= OP_SYMBOL(op)->liveTo;
2471 ic = hTabNextItem(iCodeSeqhTab,&key)) {
2473 if (SKIP_IC3(ic)) continue;
2475 /* if PCALL cannot be sure give up */
2476 if (ic->op == PCALL) return NULL;
2478 /* if SEND & not the first parameter then giveup */
2479 if (ic->op == SEND && ic->argreg != 1 &&
2480 ((isOperandInFarSpace(IC_LEFT(ic)) && !isOperandInReg(IC_LEFT(ic))) ||
2481 isOperandEqual(op,IC_LEFT(ic)))) return NULL;
2483 /* if CALL then make sure it is VOID || return value not used
2484 or the return value is assigned to this one */
2485 if (ic->op == CALL) {
2486 if (OP_SYMBOL(IC_RESULT(ic))->liveTo ==
2487 OP_SYMBOL(IC_RESULT(ic))->liveFrom) continue ;
2488 etype = getSpec(type = operandType(IC_RESULT(ic)));
2489 if (getSize(type) == 0 || isOperandEqual(op,IC_RESULT(ic)))
2494 /* special case of add with a [remat] */
2495 if (ic->op == '+' &&
2496 OP_SYMBOL(IC_LEFT(ic))->remat &&
2497 (isOperandInFarSpace(IC_RIGHT(ic)) &&
2498 !isOperandInReg(IC_RIGHT(ic)))) return NULL ;
2502 if (POINTER_GET(ic) && !isOperandEqual(IC_LEFT(ic),op) &&
2503 getSize(operandType(IC_LEFT(ic))) > 1 ) return NULL ;
2506 if (POINTER_SET(ic) && !isOperandEqual(IC_RESULT(ic),op) &&
2507 getSize(operandType(IC_RESULT(ic))) > 1 ) return NULL;
2509 /* conditionals can destroy 'b' - make sure B wont
2510 be used in this one*/
2511 if ((IS_CONDITIONAL(ic) || ic->op == '*' || ic->op == '/' ||
2512 ic->op == LEFT_OP || ic->op == RIGHT_OP ) &&
2513 getSize(operandType(op)) > 3) return NULL;
2515 /* if this is a cast to a bigger type */
2517 if (!IS_PTR(OP_SYM_TYPE(IC_RESULT(ic))) &&
2518 getSize(OP_SYM_TYPE(IC_RESULT(ic))) >
2519 getSize(OP_SYM_TYPE(IC_RIGHT(ic)))) {
2525 if (IC_RESULT(ic) && IS_SYMOP(IC_RESULT(ic)) &&
2526 !isOperandEqual(IC_RESULT(ic),op) &&
2527 ( ( ( isOperandInFarSpace(IC_RESULT(ic)) || OP_SYMBOL(IC_RESULT(ic))->onStack) &&
2528 !isOperandInReg(IC_RESULT(ic))) ||
2529 OP_SYMBOL(IC_RESULT(ic))->ruonly)) return NULL;
2531 if (IC_RIGHT(ic) && IS_SYMOP(IC_RIGHT(ic)) &&
2532 !isOperandEqual(IC_RIGHT(ic),op) &&
2533 (OP_SYMBOL(IC_RIGHT(ic))->liveTo >= ic->seq ||
2534 IS_TRUE_SYMOP(IC_RIGHT(ic)) ||
2535 OP_SYMBOL(IC_RIGHT(ic))->ruonly) &&
2536 ( ( isOperandInFarSpace(IC_RIGHT(ic)) || OP_SYMBOL(IC_RIGHT(ic))->onStack) &&
2537 !isOperandInReg(IC_RIGHT(ic))) ) return NULL;
2539 if (IC_LEFT(ic) && IS_SYMOP(IC_LEFT(ic)) &&
2540 !isOperandEqual(IC_LEFT(ic),op) &&
2541 (OP_SYMBOL(IC_LEFT(ic))->liveTo >= ic->seq ||
2542 IS_TRUE_SYMOP(IC_LEFT(ic)) ||
2543 OP_SYMBOL(IC_LEFT(ic))->ruonly) &&
2544 ( ( isOperandInFarSpace(IC_LEFT(ic)) || OP_SYMBOL(IC_LEFT(ic))->onStack) &&
2545 !isOperandInReg(IC_LEFT(ic))) ) return NULL;
2547 if (IC_LEFT(ic) && IC_RIGHT(ic) &&
2548 IS_ITEMP(IC_LEFT(ic)) && IS_ITEMP(IC_RIGHT(ic)) &&
2549 (isOperandInFarSpace(IC_LEFT(ic)) && !isOperandInReg(IC_LEFT(ic))) &&
2550 (isOperandInFarSpace(IC_RIGHT(ic)) && !isOperandInReg(IC_RIGHT(ic))))
2553 OP_SYMBOL(op)->ruonly = 1;
2554 if (OP_SYMBOL(op)->usl.spillLoc) {
2555 if (OP_SYMBOL(op)->spillA)
2556 OP_SYMBOL(op)->usl.spillLoc->allocreq--;
2557 OP_SYMBOL(op)->usl.spillLoc = NULL;
2562 /*-----------------------------------------------------------------*/
2563 /* isBitwiseOptimizable - requirements of JEAN LOUIS VERN */
2564 /*-----------------------------------------------------------------*/
2566 isBitwiseOptimizable (iCode * ic)
2568 sym_link *ltype = getSpec (operandType (IC_LEFT (ic)));
2569 sym_link *rtype = getSpec (operandType (IC_RIGHT (ic)));
2571 /* bitwise operations are considered optimizable
2572 under the following conditions (Jean-Louis VERN)
2584 if (IS_LITERAL (rtype) ||
2585 (IS_BITVAR (ltype) && IN_BITSPACE (SPEC_OCLS (ltype))))
2591 /*-----------------------------------------------------------------*/
2592 /* packRegsForAccUse - pack registers for acc use */
2593 /*-----------------------------------------------------------------*/
2595 packRegsForAccUse (iCode * ic)
2599 /* if this is an aggregate, e.g. a one byte char array */
2600 if (IS_AGGREGATE(operandType(IC_RESULT(ic)))) {
2604 /* if we are calling a reentrant function that has stack parameters */
2605 if (ic->op == CALL &&
2606 IFFUNC_ISREENT(operandType(IC_LEFT(ic))) &&
2607 FUNC_HASSTACKPARM(operandType(IC_LEFT(ic))))
2610 if (ic->op == PCALL &&
2611 IFFUNC_ISREENT(operandType(IC_LEFT(ic))->next) &&
2612 FUNC_HASSTACKPARM(operandType(IC_LEFT(ic))->next))
2615 /* if + or - then it has to be one byte result */
2616 if ((ic->op == '+' || ic->op == '-')
2617 && getSize (operandType (IC_RESULT (ic))) > 1)
2620 /* if shift operation make sure right side is not a literal */
2621 if (ic->op == RIGHT_OP &&
2622 (isOperandLiteral (IC_RIGHT (ic)) ||
2623 getSize (operandType (IC_RESULT (ic))) > 1))
2626 if (ic->op == LEFT_OP &&
2627 (isOperandLiteral (IC_RIGHT (ic)) ||
2628 getSize (operandType (IC_RESULT (ic))) > 1))
2631 if (IS_BITWISE_OP (ic) &&
2632 getSize (operandType (IC_RESULT (ic))) > 1)
2636 /* has only one definition */
2637 if (bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) > 1)
2640 /* has only one use */
2641 if (bitVectnBitsOn (OP_USES (IC_RESULT (ic))) > 1)
2644 /* and the usage immediately follows this iCode */
2645 if (!(uic = hTabItemWithKey (iCodehTab,
2646 bitVectFirstBit (OP_USES (IC_RESULT (ic))))))
2649 if (ic->next != uic)
2652 /* if it is a conditional branch then we definitely can */
2656 if (uic->op == JUMPTABLE)
2659 /* if the usage is not is an assignment
2660 or an arithmetic / bitwise / shift operation then not */
2661 if (POINTER_SET (uic) &&
2662 getSize (aggrToPtr (operandType (IC_RESULT (uic)), FALSE)) > 1)
2665 if (uic->op != '=' &&
2666 !IS_ARITHMETIC_OP (uic) &&
2667 !IS_BITWISE_OP (uic) &&
2668 uic->op != LEFT_OP &&
2669 uic->op != RIGHT_OP)
2672 /* if used in ^ operation then make sure right is not a
2674 if (uic->op == '^' && isOperandLiteral (IC_RIGHT (uic)))
2677 /* if shift operation make sure right side is not a literal */
2678 if (uic->op == RIGHT_OP &&
2679 (isOperandLiteral (IC_RIGHT (uic)) ||
2680 getSize (operandType (IC_RESULT (uic))) > 1))
2683 if (uic->op == LEFT_OP &&
2684 (isOperandLiteral (IC_RIGHT (uic)) ||
2685 getSize (operandType (IC_RESULT (uic))) > 1))
2688 /* make sure that the result of this icode is not on the
2689 stack, since acc is used to compute stack offset */
2690 if (isOperandOnStack(IC_RESULT(uic)))
2693 /* if either one of them in far space then we cannot */
2694 if ((IS_TRUE_SYMOP (IC_LEFT (uic)) &&
2695 isOperandInFarSpace (IC_LEFT (uic))) ||
2696 (IS_TRUE_SYMOP (IC_RIGHT (uic)) &&
2697 isOperandInFarSpace (IC_RIGHT (uic))))
2700 /* if the usage has only one operand then we can */
2701 if (IC_LEFT (uic) == NULL ||
2702 IC_RIGHT (uic) == NULL)
2705 /* make sure this is on the left side if not
2706 a '+' since '+' is commutative */
2707 if (ic->op != '+' &&
2708 IC_LEFT (uic)->key != IC_RESULT (ic)->key)
2711 /* if the other one is not on stack then we can */
2712 if (IC_LEFT (uic)->key == IC_RESULT (ic)->key &&
2713 (IS_ITEMP (IC_RIGHT (uic)) ||
2714 (IS_TRUE_SYMOP (IC_RIGHT (uic)) &&
2715 !OP_SYMBOL (IC_RIGHT (uic))->onStack)))
2718 if (IC_RIGHT (uic)->key == IC_RESULT (ic)->key &&
2719 (IS_ITEMP (IC_LEFT (uic)) ||
2720 (IS_TRUE_SYMOP (IC_LEFT (uic)) &&
2721 !OP_SYMBOL (IC_LEFT (uic))->onStack)))
2727 OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
2731 /*-----------------------------------------------------------------*/
2732 /* packForPush - hueristics to reduce iCode for pushing */
2733 /*-----------------------------------------------------------------*/
2735 packForPush (iCode * ic, eBBlock * ebp)
2740 if ((ic->op != IPUSH && ic->op != SEND) || !IS_ITEMP (IC_LEFT (ic)))
2743 /* must have only definition & one usage */
2744 if (bitVectnBitsOn (OP_DEFS (IC_LEFT (ic))) != 1 ||
2745 bitVectnBitsOn (OP_USES (IC_LEFT (ic))) != 1)
2748 /* find the definition */
2749 if (!(dic = hTabItemWithKey (iCodehTab,
2750 bitVectFirstBit (OP_DEFS (IC_LEFT (ic))))))
2753 if (dic->op != '=' || POINTER_SET (dic))
2756 if (dic->eBBlockNum != ic->eBBlockNum) return ;
2758 /* make sure the right side does not have any definitions
2760 dbv = OP_DEFS(IC_RIGHT(dic));
2761 for (lic = ic; lic && lic != dic ; lic = lic->prev) {
2762 if (bitVectBitValue(dbv,lic->key)) return ;
2764 /* make sure they have the same type */
2765 if (IS_SPEC(operandType(IC_LEFT(ic))))
2767 sym_link *itype=operandType(IC_LEFT(ic));
2768 sym_link *ditype=operandType(IC_RIGHT(dic));
2770 if (SPEC_USIGN(itype)!=SPEC_USIGN(ditype) ||
2771 SPEC_LONG(itype)!=SPEC_LONG(ditype))
2774 /* extend the live range of replaced operand if needed */
2775 if (OP_SYMBOL(IC_RIGHT(dic))->liveTo < OP_SYMBOL(IC_LEFT(ic))->liveTo) {
2776 OP_SYMBOL(IC_RIGHT(dic))->liveTo = OP_SYMBOL(IC_LEFT(ic))->liveTo;
2777 OP_SYMBOL(IC_RIGHT(dic))->clashes =
2778 bitVectUnion(OP_SYMBOL(IC_RIGHT(dic))->clashes,
2779 OP_SYMBOL(IC_LEFT(ic))->clashes);
2781 for (lic = ic; lic && lic != dic; lic = lic->prev)
2783 bitVectUnSetBit (lic->rlive, IC_LEFT (ic)->key);
2784 if (IS_ITEMP (IC_RIGHT (dic)))
2785 bitVectSetBit (lic->rlive, IC_RIGHT (dic)->key);
2787 /* we now we know that it has one & only one def & use
2788 and the that the definition is an assignment */
2789 IC_LEFT (ic) = IC_RIGHT (dic);
2791 remiCodeFromeBBlock (ebp, dic);
2792 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2793 hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2796 /*-----------------------------------------------------------------*/
2797 /* packRegisters - does some transformations to reduce register */
2799 /*-----------------------------------------------------------------*/
2801 packRegisters (eBBlock * ebp)
2811 /* look for assignments of the form */
2812 /* iTempNN = TRueSym (someoperation) SomeOperand */
2814 /* TrueSym := iTempNN:1 */
2815 for (ic = ebp->sch; ic; ic = ic->next)
2817 /* find assignment of the form TrueSym := iTempNN:1 */
2818 if (ic->op == '=' && !POINTER_SET (ic))
2819 change += packRegsForAssign (ic, ebp);
2826 for (ic = ebp->sch; ic; ic = ic->next)
2828 /* if this is an itemp & result of an address of a true sym
2829 then mark this as rematerialisable */
2830 if (ic->op == ADDRESS_OF &&
2831 IS_ITEMP (IC_RESULT (ic)) &&
2832 IS_TRUE_SYMOP (IC_LEFT (ic)) &&
2833 bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
2834 !OP_SYMBOL (IC_LEFT (ic))->onStack)
2837 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2838 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2839 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2843 /* if this is an itemp & used as a pointer
2844 & assigned to a literal then remat */
2845 if (IS_ASSIGN_ICODE(ic) &&
2846 IS_ITEMP(IC_RESULT(ic)) &&
2847 bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
2848 isOperandLiteral(IC_RIGHT(ic)))
2850 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2851 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2852 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2855 /* if straight assignment then carry remat flag if
2856 this is the only definition */
2857 if (ic->op == '=' &&
2858 !POINTER_SET (ic) &&
2859 IS_SYMOP (IC_RIGHT (ic)) &&
2860 OP_SYMBOL (IC_RIGHT (ic))->remat &&
2861 !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode) &&
2862 bitVectnBitsOn (OP_SYMBOL (IC_RESULT (ic))->defs) <= 1)
2865 OP_SYMBOL (IC_RESULT (ic))->remat =
2866 OP_SYMBOL (IC_RIGHT (ic))->remat;
2867 OP_SYMBOL (IC_RESULT (ic))->rematiCode =
2868 OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
2871 /* if cast to a generic pointer & the pointer being
2872 cast is remat, then we can remat this cast as well */
2873 if (ic->op == CAST &&
2874 IS_SYMOP(IC_RIGHT(ic)) &&
2875 !OP_SYMBOL(IC_RESULT(ic))->isreqv &&
2876 OP_SYMBOL(IC_RIGHT(ic))->remat ) {
2877 sym_link *to_type = operandType(IC_LEFT(ic));
2878 sym_link *from_type = operandType(IC_RIGHT(ic));
2879 if (IS_GENPTR(to_type) && IS_PTR(from_type)) {
2880 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2881 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2882 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2886 /* if this is a +/- operation with a rematerizable
2887 then mark this as rematerializable as well */
2888 if ((ic->op == '+' || ic->op == '-') &&
2889 (IS_SYMOP (IC_LEFT (ic)) &&
2890 IS_ITEMP (IC_RESULT (ic)) &&
2891 OP_SYMBOL (IC_LEFT (ic))->remat &&
2892 (!IS_SYMOP (IC_RIGHT (ic)) || !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode)) &&
2893 bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
2894 IS_OP_LITERAL (IC_RIGHT (ic))))
2897 //int i = operandLitValue(IC_RIGHT(ic));
2898 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2899 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2900 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2903 /* mark the pointer usages */
2904 if (POINTER_SET (ic) && IS_SYMOP (IC_RESULT (ic)))
2905 OP_SYMBOL (IC_RESULT (ic))->uptr = 1;
2907 if (POINTER_GET (ic) && IS_SYMOP (IC_LEFT (ic)))
2908 OP_SYMBOL (IC_LEFT (ic))->uptr = 1;
2910 if (ic->op == RETURN && IS_SYMOP (IC_LEFT(ic)))
2911 OP_SYMBOL (IC_LEFT (ic))->uptr = 1;
2913 if (ic->op == RECEIVE && ic->argreg == 1 &&
2914 IS_SYMOP (IC_RESULT (ic)) &&
2915 getSize (operandType(IC_RESULT(ic))) <= 3)
2916 OP_SYMBOL (IC_RESULT(ic))->uptr = 1;
2918 if (ic->op == SEND && ic->argreg == 1 &&
2919 IS_SYMOP(IC_LEFT(ic)) &&
2920 getSize (aggrToPtr(operandType(IC_LEFT(ic)),FALSE)) <= 3)
2921 OP_SYMBOL (IC_LEFT(ic))->uptr = 1;
2925 /* if we are using a symbol on the stack
2926 then we should say ds390_ptrRegReq */
2927 if (options.useXstack && ic->parmPush
2928 && (ic->op == IPUSH || ic->op == IPOP))
2930 if (ic->op == IFX && IS_SYMOP (IC_COND (ic)))
2931 ds390_ptrRegReq += ((OP_SYMBOL (IC_COND (ic))->onStack ? !options.stack10bit : 0) +
2932 OP_SYMBOL (IC_COND (ic))->iaccess +
2933 (SPEC_OCLS(OP_SYMBOL (IC_COND (ic))->etype) == idata));
2934 else if (ic->op == JUMPTABLE && IS_SYMOP (IC_JTCOND (ic)))
2935 ds390_ptrRegReq += ((OP_SYMBOL (IC_JTCOND (ic))->onStack ? !options.stack10bit : 0) +
2936 OP_SYMBOL (IC_JTCOND (ic))->iaccess +
2937 (SPEC_OCLS(OP_SYMBOL (IC_JTCOND (ic))->etype) == idata));
2940 if (IS_SYMOP (IC_LEFT (ic)))
2941 ds390_ptrRegReq += ((OP_SYMBOL (IC_LEFT (ic))->onStack ? !options.stack10bit : 0) +
2942 OP_SYMBOL (IC_LEFT (ic))->iaccess +
2943 (SPEC_OCLS(OP_SYMBOL (IC_LEFT (ic))->etype) == idata));
2944 if (IS_SYMOP (IC_RIGHT (ic)))
2945 ds390_ptrRegReq += ((OP_SYMBOL (IC_RIGHT (ic))->onStack ? !options.stack10bit : 0) +
2946 OP_SYMBOL (IC_RIGHT (ic))->iaccess +
2947 (SPEC_OCLS(OP_SYMBOL (IC_RIGHT (ic))->etype) == idata));
2948 if (IS_SYMOP (IC_RESULT (ic)))
2949 ds390_ptrRegReq += ((OP_SYMBOL (IC_RESULT (ic))->onStack ? !options.stack10bit : 0) +
2950 OP_SYMBOL (IC_RESULT (ic))->iaccess +
2951 (SPEC_OCLS(OP_SYMBOL (IC_RESULT (ic))->etype) == idata));
2955 /* if the condition of an if instruction
2956 is defined in the previous instruction and
2957 this is the only usage then
2958 mark the itemp as a conditional */
2959 if ((IS_CONDITIONAL (ic) ||
2960 (IS_BITWISE_OP(ic) && isBitwiseOptimizable (ic))) &&
2961 ic->next && ic->next->op == IFX &&
2962 bitVectnBitsOn (OP_USES(IC_RESULT(ic)))==1 &&
2963 isOperandEqual (IC_RESULT (ic), IC_COND (ic->next)) &&
2964 OP_SYMBOL (IC_RESULT (ic))->liveTo <= ic->next->seq)
2966 OP_SYMBOL (IC_RESULT (ic))->regType = REG_CND;
2970 /* reduce for support function calls */
2971 if (ic->supportRtn || ic->op == '+' || ic->op == '-')
2972 packRegsForSupport (ic, ebp);
2974 /* some cases the redundant moves can
2975 can be eliminated for return statements . Can be elminated for the first SEND */
2976 if ((ic->op == RETURN ||
2977 ((ic->op == SEND || ic->op == RECEIVE)&& ic->argreg == 1)) &&
2978 !isOperandInFarSpace (IC_LEFT (ic)) &&
2981 packRegsDPTRuse (IC_LEFT (ic));
2984 if (ic->op == CALL) {
2985 sym_link *ftype = operandType(IC_LEFT(ic));
2986 if (getSize(operandType(IC_RESULT(ic))) <= 4 &&
2987 !IFFUNC_ISBUILTIN(ftype)) {
2988 packRegsDPTRuse (IC_RESULT (ic));
2992 /* if pointer set & left has a size more than
2993 one and right is not in far space */
2994 if (POINTER_SET (ic) &&
2995 !isOperandInFarSpace (IC_RIGHT (ic)) &&
2996 IS_SYMOP (IC_RESULT (ic)) &&
2997 !OP_SYMBOL (IC_RESULT (ic))->remat &&
2998 !IS_OP_RUONLY (IC_RIGHT (ic)) &&
2999 getSize (aggrToPtr (operandType (IC_RESULT (ic)), FALSE)) > 1) {
3001 packRegsDPTRuse (IC_RESULT (ic));
3004 /* if pointer get */
3005 if (POINTER_GET (ic) &&
3006 !isOperandInFarSpace (IC_RESULT (ic)) &&
3007 IS_SYMOP (IC_LEFT (ic)) &&
3008 !OP_SYMBOL (IC_LEFT (ic))->remat &&
3009 !IS_OP_RUONLY (IC_RESULT (ic)) &&
3010 getSize (aggrToPtr (operandType (IC_LEFT (ic)), FALSE)) > 1) {
3012 packRegsDPTRuse (IC_LEFT (ic));
3015 /* if this is cast for intergral promotion then
3016 check if only use of the definition of the
3017 operand being casted/ if yes then replace
3018 the result of that arithmetic operation with
3019 this result and get rid of the cast */
3022 sym_link *fromType = operandType (IC_RIGHT (ic));
3023 sym_link *toType = operandType (IC_LEFT (ic));
3025 if (IS_INTEGRAL (fromType) && IS_INTEGRAL (toType) &&
3026 getSize (fromType) != getSize (toType) &&
3027 SPEC_USIGN (fromType) == SPEC_USIGN (toType))
3030 iCode *dic = packRegsDPTRuse (IC_RIGHT (ic));
3033 if (IS_ARITHMETIC_OP (dic))
3035 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
3036 IC_RESULT (dic) = IC_RESULT (ic);
3037 remiCodeFromeBBlock (ebp, ic);
3038 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
3039 hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
3040 OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
3044 OP_SYMBOL (IC_RIGHT (ic))->ruonly = 0;
3050 /* if the type from and type to are the same
3051 then if this is the only use then packit */
3052 if (compareType (operandType (IC_RIGHT (ic)),
3053 operandType (IC_LEFT (ic))) == 1)
3055 iCode *dic = packRegsDPTRuse (IC_RIGHT (ic));
3058 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
3059 IC_RESULT (dic) = IC_RESULT (ic);
3060 remiCodeFromeBBlock (ebp, ic);
3061 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
3062 hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
3063 OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
3071 iTempNN := (some variable in farspace) V1
3076 if (ic->op == IPUSH || ic->op == SEND)
3078 packForPush (ic, ebp);
3082 /* pack registers for accumulator use, when the
3083 result of an arithmetic or bit wise operation
3084 has only one use, that use is immediately following
3085 the defintion and the using iCode has only one
3086 operand or has two operands but one is literal &
3087 the result of that operation is not on stack then
3088 we can leave the result of this operation in acc:b
3090 if ((IS_ARITHMETIC_OP (ic)
3091 || IS_CONDITIONAL(ic)
3092 || IS_BITWISE_OP (ic)
3093 || ic->op == LEFT_OP || ic->op == RIGHT_OP
3094 || (ic->op == ADDRESS_OF && isOperandOnStack (IC_LEFT (ic)))
3096 IS_ITEMP (IC_RESULT (ic)) &&
3097 getSize (operandType (IC_RESULT (ic))) <= 2)
3099 packRegsForAccUse (ic);
3104 /*-----------------------------------------------------------------*/
3105 /* assignRegisters - assigns registers to each live range as need */
3106 /*-----------------------------------------------------------------*/
3108 ds390_assignRegisters (eBBlock ** ebbs, int count)
3113 setToNull ((void *) &_G.funcrUsed);
3114 setToNull ((void *) &_G.regAssigned);
3115 setToNull ((void *) &_G.totRegAssigned);
3116 setToNull ((void *) &_G.funcrUsed);
3117 ds390_ptrRegReq = _G.stackExtend = _G.dataExtend = 0;
3119 if (options.model != MODEL_FLAT24) options.stack10bit = 0;
3120 /* change assignments this will remove some
3121 live ranges reducing some register pressure */
3122 for (i = 0; i < count; i++)
3123 packRegisters (ebbs[i]);
3125 /* liveranges probably changed by register packing
3126 so we compute them again */
3127 recomputeLiveRanges (ebbs, count);
3129 if (options.dump_pack)
3130 dumpEbbsToFileExt (DUMP_PACK, ebbs, count);
3132 /* first determine for each live range the number of
3133 registers & the type of registers required for each */
3136 /* and serially allocate registers */
3137 serialRegAssign (ebbs, count);
3144 /* if stack was extended then tell the user */
3147 /* werror(W_TOOMANY_SPILS,"stack", */
3148 /* _G.stackExtend,currFunc->name,""); */
3154 /* werror(W_TOOMANY_SPILS,"data space", */
3155 /* _G.dataExtend,currFunc->name,""); */
3159 /* after that create the register mask
3160 for each of the instruction */
3161 createRegMask (ebbs, count);
3163 /* redo that offsets for stacked automatic variables */
3165 redoStackOffsets ();
3167 /* make sure r0 & r1 are flagged as used if they might be used */
3169 if (currFunc && ds390_ptrRegReq)
3171 currFunc->regsUsed = bitVectSetBit (currFunc->regsUsed, R0_IDX);
3172 currFunc->regsUsed = bitVectSetBit (currFunc->regsUsed, R1_IDX);
3175 if (options.dump_rassgn) {
3176 dumpEbbsToFileExt (DUMP_RASSGN, ebbs, count);
3177 dumpLiveRanges (DUMP_LRANGE, liveRanges);
3180 /* do the overlaysegment stuff SDCCmem.c */
3181 doOverlays (ebbs, count);
3183 /* now get back the chain */
3184 ic = iCodeLabelOptimize (iCodeFromeBBlock (ebbs, count));
3188 /* free up any _G.stackSpil locations allocated */
3189 applyToSet (_G.stackSpil, deallocStackSpil);
3191 setToNull ((void *) &_G.stackSpil);
3192 setToNull ((void *) &_G.spiltSet);
3193 /* mark all registers as free */