1 /*------------------------------------------------------------------------
3 SDCCralloc.c - source file for register allocation. (8051) specific
5 Written By - Sandeep Dutta . sandeep.dutta@usa.net (1998)
7 This program is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 2, or (at your option) any
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21 In other words, you are welcome to use, share and improve this program.
22 You are forbidden to forbid anyone else to use, share and improve
23 what you give them. Help stamp out software-hoarding!
24 -------------------------------------------------------------------------*/
30 /*-----------------------------------------------------------------*/
31 /* At this point we start getting processor specific although */
32 /* some routines are non-processor specific & can be reused when */
33 /* targetting other processors. The decision for this will have */
34 /* to be made on a routine by routine basis */
35 /* routines used to pack registers are most definitely not reusable */
36 /* since the pack the registers depending strictly on the MCU */
37 /*-----------------------------------------------------------------*/
39 extern void gen51Code (iCode *);
48 bitVect *totRegAssigned; /* final set of LRs that got into registers */
51 bitVect *funcrUsed; /* registers used in a function */
54 bitVect *allBitregs; /* all bit registers */
58 /* Shared with gen.c */
59 int mcs51_ptrRegReq; /* one byte pointer register required */
65 {REG_GPR, R2_IDX, REG_GPR, "r2", "ar2", "0", 2, 1},
66 {REG_GPR, R3_IDX, REG_GPR, "r3", "ar3", "0", 3, 1},
67 {REG_GPR, R4_IDX, REG_GPR, "r4", "ar4", "0", 4, 1},
68 {REG_GPR, R5_IDX, REG_GPR, "r5", "ar5", "0", 5, 1},
69 {REG_GPR, R6_IDX, REG_GPR, "r6", "ar6", "0", 6, 1},
70 {REG_GPR, R7_IDX, REG_GPR, "r7", "ar7", "0", 7, 1},
71 {REG_PTR, R0_IDX, REG_PTR, "r0", "ar0", "0", 0, 1},
72 {REG_PTR, R1_IDX, REG_PTR, "r1", "ar1", "0", 1, 1},
73 {REG_BIT, B0_IDX, REG_BIT, "b0", "b0", "bits", 0, 1},
74 {REG_BIT, B1_IDX, REG_BIT, "b1", "b1", "bits", 1, 1},
75 {REG_BIT, B2_IDX, REG_BIT, "b2", "b2", "bits", 2, 1},
76 {REG_BIT, B3_IDX, REG_BIT, "b3", "b3", "bits", 3, 1},
77 {REG_BIT, B4_IDX, REG_BIT, "b4", "b4", "bits", 4, 1},
78 {REG_BIT, B5_IDX, REG_BIT, "b5", "b5", "bits", 5, 1},
79 {REG_BIT, B6_IDX, REG_BIT, "b6", "b6", "bits", 6, 1},
80 {REG_BIT, B7_IDX, REG_BIT, "b7", "b7", "bits", 7, 1},
81 {REG_GPR, X8_IDX, REG_GPR, "x8", "x8", "xreg", 0, 1},
82 {REG_GPR, X9_IDX, REG_GPR, "x9", "x9", "xreg", 1, 1},
83 {REG_GPR, X10_IDX, REG_GPR, "x10", "x10", "xreg", 2, 1},
84 {REG_GPR, X11_IDX, REG_GPR, "x11", "x11", "xreg", 3, 1},
85 {REG_GPR, X12_IDX, REG_GPR, "x12", "x12", "xreg", 4, 1},
86 {REG_CND, CND_IDX, REG_CND, "C", "psw", "0xd0", 0, 1},
87 {0, DPL_IDX, 0, "dpl", "dpl", "0x82", 0, 0},
88 {0, DPH_IDX, 0, "dph", "dph", "0x83", 0, 0},
89 {0, B_IDX, 0, "b", "b", "0xf0", 0, 0},
90 {0, A_IDX, 0, "a", "acc", "0xe0", 0, 0},
93 static void spillThis (symbol *);
94 static void freeAllRegs ();
96 /*-----------------------------------------------------------------*/
97 /* allocReg - allocates register of given type */
98 /*-----------------------------------------------------------------*/
100 allocReg (short type)
104 for (i = 0; i < mcs51_nRegs; i++)
107 /* if type is given as 0 then any
108 free register will do */
112 regs8051[i].isFree = 0;
115 bitVectSetBit (currFunc->regsUsed, i);
118 /* other wise look for specific type
120 if (regs8051[i].isFree &&
121 regs8051[i].type == type)
123 regs8051[i].isFree = 0;
126 bitVectSetBit (currFunc->regsUsed, i);
133 /*-----------------------------------------------------------------*/
134 /* allocThisReg - allocates a particular register (if free) */
135 /*-----------------------------------------------------------------*/
137 allocThisReg (regs * reg)
144 currFunc->regsUsed = bitVectSetBit (currFunc->regsUsed, reg->rIdx);
150 /*-----------------------------------------------------------------*/
151 /* mcs51_regWithIdx - returns pointer to register with index number*/
152 /*-----------------------------------------------------------------*/
154 mcs51_regWithIdx (int idx)
158 for (i = 0; i < sizeof(regs8051)/sizeof(regs); i++)
159 if (regs8051[i].rIdx == idx)
162 werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
163 "regWithIdx not found");
167 /*-----------------------------------------------------------------*/
168 /* freeReg - frees a register */
169 /*-----------------------------------------------------------------*/
175 werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
176 "freeReg - Freeing NULL register");
184 /*-----------------------------------------------------------------*/
185 /* nFreeRegs - returns number of free registers */
186 /*-----------------------------------------------------------------*/
193 for (i = 0; i < mcs51_nRegs; i++)
194 if (regs8051[i].isFree && regs8051[i].type == type)
199 /*-----------------------------------------------------------------*/
200 /* nfreeRegsType - free registers with type */
201 /*-----------------------------------------------------------------*/
203 nfreeRegsType (int type)
208 if ((nfr = nFreeRegs (type)) == 0)
209 return nFreeRegs (REG_GPR);
212 return nFreeRegs (type);
215 /*-----------------------------------------------------------------*/
216 /* useReg - marks a register as used */
217 /*-----------------------------------------------------------------*/
224 /*-----------------------------------------------------------------*/
225 /* computeSpillable - given a point find the spillable live ranges */
226 /*-----------------------------------------------------------------*/
228 computeSpillable (iCode * ic)
232 /* spillable live ranges are those that are live at this
233 point . the following categories need to be subtracted
235 a) - those that are already spilt
236 b) - if being used by this one
237 c) - defined by this one */
239 spillable = bitVectCopy (ic->rlive);
241 bitVectCplAnd (spillable, _G.spiltSet); /* those already spilt */
243 bitVectCplAnd (spillable, ic->uses); /* used in this one */
244 bitVectUnSetBit (spillable, ic->defKey);
245 spillable = bitVectIntersect (spillable, _G.regAssigned);
250 /*-----------------------------------------------------------------*/
251 /* bitType - will return 1 if the symbol has type REG_BIT */
252 /*-----------------------------------------------------------------*/
254 bitType (symbol * sym, eBBlock * ebp, iCode * ic)
256 return (sym->regType == REG_BIT ? 1 : 0);
259 /*-----------------------------------------------------------------*/
260 /* noSpilLoc - return true if a variable has no spil location */
261 /*-----------------------------------------------------------------*/
263 noSpilLoc (symbol * sym, eBBlock * ebp, iCode * ic)
265 return (sym->usl.spillLoc ? 0 : 1);
268 /*-----------------------------------------------------------------*/
269 /* hasSpilLoc - will return 1 if the symbol has spil location */
270 /*-----------------------------------------------------------------*/
272 hasSpilLoc (symbol * sym, eBBlock * ebp, iCode * ic)
274 return (sym->usl.spillLoc ? 1 : 0);
277 /*-----------------------------------------------------------------*/
278 /* directSpilLoc - will return 1 if the spillocation is in direct */
279 /*-----------------------------------------------------------------*/
281 directSpilLoc (symbol * sym, eBBlock * ebp, iCode * ic)
283 if (sym->usl.spillLoc &&
284 (IN_DIRSPACE (SPEC_OCLS (sym->usl.spillLoc->etype))))
290 /*-----------------------------------------------------------------*/
291 /* hasSpilLocnoUptr - will return 1 if the symbol has spil location */
292 /* but is not used as a pointer */
293 /*-----------------------------------------------------------------*/
295 hasSpilLocnoUptr (symbol * sym, eBBlock * ebp, iCode * ic)
297 return ((sym->usl.spillLoc && !sym->uptr) ? 1 : 0);
300 /*-----------------------------------------------------------------*/
301 /* rematable - will return 1 if the remat flag is set */
302 /*-----------------------------------------------------------------*/
304 rematable (symbol * sym, eBBlock * ebp, iCode * ic)
309 /*-----------------------------------------------------------------*/
310 /* notUsedInRemaining - not used or defined in remain of the block */
311 /*-----------------------------------------------------------------*/
313 notUsedInRemaining (symbol * sym, eBBlock * ebp, iCode * ic)
315 return ((usedInRemaining (operandFromSymbol (sym), ic) ? 0 : 1) &&
316 allDefsOutOfRange (sym->defs, ebp->fSeq, ebp->lSeq));
319 /*-----------------------------------------------------------------*/
320 /* allLRs - return true for all */
321 /*-----------------------------------------------------------------*/
323 allLRs (symbol * sym, eBBlock * ebp, iCode * ic)
328 /*-----------------------------------------------------------------*/
329 /* liveRangesWith - applies function to a given set of live range */
330 /*-----------------------------------------------------------------*/
332 liveRangesWith (bitVect * lrs, int (func) (symbol *, eBBlock *, iCode *),
333 eBBlock * ebp, iCode * ic)
338 if (!lrs || !lrs->size)
341 for (i = 1; i < lrs->size; i++)
344 if (!bitVectBitValue (lrs, i))
347 /* if we don't find it in the live range
348 hash table we are in serious trouble */
349 if (!(sym = hTabItemWithKey (liveRanges, i)))
351 werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
352 "liveRangesWith could not find liveRange");
356 if (func (sym, ebp, ic) && bitVectBitValue (_G.regAssigned, sym->key))
357 addSetHead (&rset, sym);
364 /*-----------------------------------------------------------------*/
365 /* leastUsedLR - given a set determines which is the least used */
366 /*-----------------------------------------------------------------*/
368 leastUsedLR (set * sset)
370 symbol *sym = NULL, *lsym = NULL;
372 sym = lsym = setFirstItem (sset);
377 for (; lsym; lsym = setNextItem (sset))
380 /* if usage is the same then prefer
381 to spill the smaller of the two */
382 if (lsym->used == sym->used)
383 if (getSize (lsym->type) < getSize (sym->type))
387 if (lsym->used < sym->used)
392 setToNull ((void *) &sset);
397 /*-----------------------------------------------------------------*/
398 /* noOverLap - will iterate through the list looking for over lap */
399 /*-----------------------------------------------------------------*/
401 noOverLap (set * itmpStack, symbol * fsym)
405 for (sym = setFirstItem (itmpStack); sym;
406 sym = setNextItem (itmpStack))
408 if (bitVectBitValue(sym->clashes,fsym->key)) return 0;
413 /*-----------------------------------------------------------------*/
414 /* isFree - will return 1 if the a free spil location is found */
415 /*-----------------------------------------------------------------*/
420 V_ARG (symbol **, sloc);
421 V_ARG (symbol *, fsym);
423 /* if already found */
427 /* if it is free && and the itmp assigned to
428 this does not have any overlapping live ranges
429 with the one currently being assigned and
430 the size can be accomodated */
432 noOverLap (sym->usl.itmpStack, fsym) &&
433 getSize (sym->type) >= getSize (fsym->type))
442 /*-----------------------------------------------------------------*/
443 /* spillLRWithPtrReg :- will spil those live ranges which use PTR */
444 /*-----------------------------------------------------------------*/
446 spillLRWithPtrReg (symbol * forSym)
452 if (!_G.regAssigned ||
453 bitVectIsZero (_G.regAssigned))
456 r0 = mcs51_regWithIdx (R0_IDX);
457 r1 = mcs51_regWithIdx (R1_IDX);
459 /* for all live ranges */
460 for (lrsym = hTabFirstItem (liveRanges, &k); lrsym;
461 lrsym = hTabNextItem (liveRanges, &k))
465 /* if no registers assigned to it or spilt */
466 /* if it does not overlap this then
467 no need to spill it */
469 if (lrsym->isspilt || !lrsym->nRegs ||
470 (lrsym->liveTo < forSym->liveFrom))
473 /* go thru the registers : if it is either
474 r0 or r1 then spill it */
475 for (j = 0; j < lrsym->nRegs; j++)
476 if (lrsym->regs[j] == r0 ||
477 lrsym->regs[j] == r1)
486 /*-----------------------------------------------------------------*/
487 /* createStackSpil - create a location on the stack to spil */
488 /*-----------------------------------------------------------------*/
490 createStackSpil (symbol * sym)
493 int useXstack, model;
497 /* first go try and find a free one that is already
498 existing on the stack */
499 if (applyToSet (_G.stackSpil, isFree, &sloc, sym))
501 /* found a free one : just update & return */
502 sym->usl.spillLoc = sloc;
505 addSetHead (&sloc->usl.itmpStack, sym);
509 /* could not then have to create one , this is the hard part
510 we need to allocate this on the stack : this is really a
511 hack!! but cannot think of anything better at this time */
513 if (SNPRINTF (slocBuffer, sizeof(slocBuffer),
514 "sloc%d", _G.slocNum++) >= sizeof (slocBuffer))
516 fprintf (stderr, "***Internal error: slocBuffer overflowed: %s:%d\n",
521 sloc = newiTemp (slocBuffer);
523 /* set the type to the spilling symbol */
524 sloc->type = copyLinkChain (sym->type);
525 sloc->etype = getSpec (sloc->type);
526 if (!IS_BIT (sloc->etype))
528 SPEC_SCLS (sloc->etype) = S_DATA;
530 else if (SPEC_SCLS (sloc->etype) == S_SBIT)
532 SPEC_SCLS (sloc->etype) = S_BIT;
534 SPEC_EXTR (sloc->etype) = 0;
535 SPEC_STAT (sloc->etype) = 0;
536 SPEC_VOLATILE(sloc->etype) = 0;
537 SPEC_ABSA(sloc->etype) = 0;
539 /* we don't allow it to be allocated
540 onto the external stack since : so we
541 temporarily turn it off ; we also
542 turn off memory model to prevent
543 the spil from going to the external storage
546 useXstack = options.useXstack;
547 model = options.model;
548 /* noOverlay = options.noOverlay; */
549 /* options.noOverlay = 1; */
550 options.model = options.useXstack = 0;
554 options.useXstack = useXstack;
555 options.model = model;
556 /* options.noOverlay = noOverlay; */
557 sloc->isref = 1; /* to prevent compiler warning */
559 /* if it is on the stack then update the stack */
560 if (IN_STACK (sloc->etype))
562 currFunc->stack += getSize (sloc->type);
563 _G.stackExtend += getSize (sloc->type);
566 _G.dataExtend += getSize (sloc->type);
568 /* add it to the _G.stackSpil set */
569 addSetHead (&_G.stackSpil, sloc);
570 sym->usl.spillLoc = sloc;
573 /* add it to the set of itempStack set
574 of the spill location */
575 addSetHead (&sloc->usl.itmpStack, sym);
579 /*-----------------------------------------------------------------*/
580 /* isSpiltOnStack - returns true if the spil location is on stack */
581 /* or otherwise needs a pointer register */
582 /*-----------------------------------------------------------------*/
584 isSpiltOnStack (symbol * sym)
594 /* if (sym->_G.stackSpil) */
597 if (!sym->usl.spillLoc)
600 if (sym->usl.spillLoc->onStack || sym->usl.spillLoc->iaccess)
603 etype = getSpec (sym->usl.spillLoc->type);
604 if (IN_STACK (etype))
610 /*-----------------------------------------------------------------*/
611 /* spillThis - spils a specific operand */
612 /*-----------------------------------------------------------------*/
614 spillThis (symbol * sym)
617 /* if this is rematerializable or has a spillLocation
618 we are okay, else we need to create a spillLocation
620 if (!(sym->remat || sym->usl.spillLoc))
621 createStackSpil (sym);
623 /* mark it has spilt & put it in the spilt set */
624 sym->isspilt = sym->spillA = 1;
625 _G.spiltSet = bitVectSetBit (_G.spiltSet, sym->key);
627 bitVectUnSetBit (_G.regAssigned, sym->key);
628 bitVectUnSetBit (_G.totRegAssigned, sym->key);
630 for (i = 0; i < sym->nRegs; i++)
634 freeReg (sym->regs[i]);
638 /* if spilt on stack then free up r0 & r1
639 if they could have been assigned to some
641 if (!mcs51_ptrRegReq && isSpiltOnStack (sym))
644 spillLRWithPtrReg (sym);
647 if (sym->usl.spillLoc && !sym->remat)
648 sym->usl.spillLoc->allocreq++;
652 /*-----------------------------------------------------------------*/
653 /* selectSpil - select a iTemp to spil : rather a simple procedure */
654 /*-----------------------------------------------------------------*/
656 selectSpil (iCode * ic, eBBlock * ebp, symbol * forSym)
658 bitVect *lrcs = NULL;
662 /* get the spillable live ranges */
663 lrcs = computeSpillable (ic);
665 /* remove incompatible registers */
666 if ((forSym->regType == REG_PTR) || (forSym->regType == REG_GPR))
668 selectS = liveRangesWith (lrcs, bitType, ebp, ic);
670 for (sym = setFirstItem (selectS); sym; sym = setNextItem (selectS))
672 bitVectUnSetBit (lrcs, sym->key);
676 /* get all live ranges that are rematerializable */
677 if ((selectS = liveRangesWith (lrcs, rematable, ebp, ic)))
679 /* return the least used of these */
680 return leastUsedLR (selectS);
683 /* get live ranges with spillLocations in direct space */
684 if ((selectS = liveRangesWith (lrcs, directSpilLoc, ebp, ic)))
686 sym = leastUsedLR (selectS);
687 strncpyz (sym->rname,
688 sym->usl.spillLoc->rname[0] ?
689 sym->usl.spillLoc->rname : sym->usl.spillLoc->name,
692 /* mark it as allocation required */
693 sym->usl.spillLoc->allocreq++;
697 /* if the symbol is local to the block then */
698 if (forSym->liveTo < ebp->lSeq)
700 /* check if there are any live ranges allocated
701 to registers that are not used in this block */
702 if (!_G.blockSpil && (selectS = liveRangesWith (lrcs, notUsedInBlock, ebp, ic)))
704 sym = leastUsedLR (selectS);
705 /* if this is not rematerializable */
714 /* check if there are any live ranges that not
715 used in the remainder of the block */
717 !isiCodeInFunctionCall (ic) &&
718 (selectS = liveRangesWith (lrcs, notUsedInRemaining, ebp, ic)))
720 sym = leastUsedLR (selectS);
733 /* find live ranges with spillocation && not used as pointers */
734 if ((selectS = liveRangesWith (lrcs, hasSpilLocnoUptr, ebp, ic)))
736 sym = leastUsedLR (selectS);
737 /* mark this as allocation required */
738 sym->usl.spillLoc->allocreq++;
742 /* find live ranges with spillocation */
743 if ((selectS = liveRangesWith (lrcs, hasSpilLoc, ebp, ic)))
745 sym = leastUsedLR (selectS);
746 sym->usl.spillLoc->allocreq++;
750 /* couldn't find then we need to create a spil
751 location on the stack , for which one? the least
753 if ((selectS = liveRangesWith (lrcs, noSpilLoc, ebp, ic)))
755 /* return a created spil location */
756 sym = createStackSpil (leastUsedLR (selectS));
757 sym->usl.spillLoc->allocreq++;
761 /* this is an extreme situation we will spill
762 this one : happens very rarely but it does happen */
768 /*-----------------------------------------------------------------*/
769 /* spilSomething - spil some variable & mark registers as free */
770 /*-----------------------------------------------------------------*/
772 spilSomething (iCode * ic, eBBlock * ebp, symbol * forSym)
777 /* get something we can spil */
778 ssym = selectSpil (ic, ebp, forSym);
780 /* mark it as spilt */
781 ssym->isspilt = ssym->spillA = 1;
782 _G.spiltSet = bitVectSetBit (_G.spiltSet, ssym->key);
784 /* mark it as not register assigned &
785 take it away from the set */
786 bitVectUnSetBit (_G.regAssigned, ssym->key);
787 bitVectUnSetBit (_G.totRegAssigned, ssym->key);
789 /* mark the registers as free */
790 for (i = 0; i < ssym->nRegs; i++)
792 freeReg (ssym->regs[i]);
794 /* if spilt on stack then free up r0 & r1
795 if they could have been assigned to as gprs */
796 if (!mcs51_ptrRegReq && isSpiltOnStack (ssym))
799 spillLRWithPtrReg (ssym);
802 /* if this was a block level spil then insert push & pop
803 at the start & end of block respectively */
806 iCode *nic = newiCode (IPUSH, operandFromSymbol (ssym), NULL);
807 /* add push to the start of the block */
808 addiCodeToeBBlock (ebp, nic, (ebp->sch->op == LABEL ?
809 ebp->sch->next : ebp->sch));
810 nic = newiCode (IPOP, operandFromSymbol (ssym), NULL);
811 /* add pop to the end of the block */
812 addiCodeToeBBlock (ebp, nic, NULL);
815 /* if spilt because not used in the remainder of the
816 block then add a push before this instruction and
817 a pop at the end of the block */
818 if (ssym->remainSpil)
821 iCode *nic = newiCode (IPUSH, operandFromSymbol (ssym), NULL);
822 /* add push just before this instruction */
823 addiCodeToeBBlock (ebp, nic, ic);
825 nic = newiCode (IPOP, operandFromSymbol (ssym), NULL);
826 /* add pop to the end of the block */
827 addiCodeToeBBlock (ebp, nic, NULL);
836 /*-----------------------------------------------------------------*/
837 /* getRegPtr - will try for PTR if not a GPR type if not spil */
838 /*-----------------------------------------------------------------*/
840 getRegPtr (iCode * ic, eBBlock * ebp, symbol * sym)
846 /* try for a ptr type */
847 if ((reg = allocReg (REG_PTR)))
850 /* try for gpr type */
851 if ((reg = allocReg (REG_GPR)))
854 /* we have to spil */
855 if (!spilSomething (ic, ebp, sym))
858 /* make sure partially assigned registers aren't reused */
859 for (j=0; j<=sym->nRegs; j++)
861 sym->regs[j]->isFree = 0;
863 /* this looks like an infinite loop but
864 in really selectSpil will abort */
868 /*-----------------------------------------------------------------*/
869 /* getRegGpr - will try for GPR if not spil */
870 /*-----------------------------------------------------------------*/
872 getRegGpr (iCode * ic, eBBlock * ebp, symbol * sym)
878 /* try for gpr type */
879 if ((reg = allocReg (REG_GPR)))
882 if (!mcs51_ptrRegReq)
883 if ((reg = allocReg (REG_PTR)))
886 /* we have to spil */
887 if (!spilSomething (ic, ebp, sym))
890 /* make sure partially assigned registers aren't reused */
891 for (j=0; j<=sym->nRegs; j++)
893 sym->regs[j]->isFree = 0;
895 /* this looks like an infinite loop but
896 in really selectSpil will abort */
900 /*-----------------------------------------------------------------*/
901 /* getRegBit - will try for Bit if not spill this */
902 /*-----------------------------------------------------------------*/
903 static regs *getRegBit (symbol * sym)
907 /* try for a bit type */
908 if ((reg = allocReg (REG_BIT)))
915 /*-----------------------------------------------------------------*/
916 /* getRegPtrNoSpil - get it cannot be spilt */
917 /*-----------------------------------------------------------------*/
918 static regs *getRegPtrNoSpil()
922 /* try for a ptr type */
923 if ((reg = allocReg (REG_PTR)))
926 /* try for gpr type */
927 if ((reg = allocReg (REG_GPR)))
932 /* just to make the compiler happy */
936 /*-----------------------------------------------------------------*/
937 /* getRegGprNoSpil - get it cannot be spilt */
938 /*-----------------------------------------------------------------*/
939 static regs *getRegGprNoSpil()
943 if ((reg = allocReg (REG_GPR)))
946 if (!mcs51_ptrRegReq)
947 if ((reg = allocReg (REG_PTR)))
952 /* just to make the compiler happy */
956 /*-----------------------------------------------------------------*/
957 /* getRegBitNoSpil - get it cannot be spilt */
958 /*-----------------------------------------------------------------*/
959 static regs *getRegBitNoSpil()
963 /* try for a ptr type */
964 if ((reg = allocReg (REG_BIT)))
967 /* try for gpr type */
968 if ((reg = allocReg (REG_GPR)))
973 /* just to make the compiler happy */
977 /*-----------------------------------------------------------------*/
978 /* symHasReg - symbol has a given register */
979 /*-----------------------------------------------------------------*/
981 symHasReg (symbol * sym, regs * reg)
985 for (i = 0; i < sym->nRegs; i++)
986 if (sym->regs[i] == reg)
992 /*-----------------------------------------------------------------*/
993 /* updateRegUsage - update the registers in use at the start of */
995 /*-----------------------------------------------------------------*/
997 updateRegUsage (iCode * ic)
1001 for (reg=0; reg<mcs51_nRegs; reg++)
1003 if (regs8051[reg].isFree)
1005 ic->riu &= ~(1<<regs8051[reg].offset);
1009 ic->riu |= (1<<regs8051[reg].offset);
1010 BitBankUsed |= (reg >= 8);
1015 /*-----------------------------------------------------------------*/
1016 /* deassignLRs - check the live to and if they have registers & are */
1017 /* not spilt then free up the registers */
1018 /*-----------------------------------------------------------------*/
1020 deassignLRs (iCode * ic, eBBlock * ebp)
1026 for (sym = hTabFirstItem (liveRanges, &k); sym;
1027 sym = hTabNextItem (liveRanges, &k))
1030 symbol *psym = NULL;
1031 /* if it does not end here */
1032 if (sym->liveTo > ic->seq)
1035 /* if it was spilt on stack then we can
1036 mark the stack spil location as free */
1041 sym->usl.spillLoc->isFree = 1;
1047 if (!bitVectBitValue (_G.regAssigned, sym->key))
1050 /* special case check if this is an IFX &
1051 the privious one was a pop and the
1052 previous one was not spilt then keep track
1054 if (ic->op == IFX && ic->prev &&
1055 ic->prev->op == IPOP &&
1056 !ic->prev->parmPush &&
1057 !OP_SYMBOL (IC_LEFT (ic->prev))->isspilt)
1058 psym = OP_SYMBOL (IC_LEFT (ic->prev));
1064 bitVectUnSetBit (_G.regAssigned, sym->key);
1066 /* if the result of this one needs registers
1067 and does not have it then assign it right
1069 if (IC_RESULT (ic) &&
1070 !(SKIP_IC2 (ic) || /* not a special icode */
1071 ic->op == JUMPTABLE ||
1076 POINTER_SET (ic)) &&
1077 (result = OP_SYMBOL (IC_RESULT (ic))) && /* has a result */
1078 result->liveTo > ic->seq && /* and will live beyond this */
1079 result->liveTo <= ebp->lSeq && /* does not go beyond this block */
1080 result->liveFrom == ic->seq && /* does not start before here */
1081 result->regType == sym->regType && /* same register types */
1082 result->nRegs && /* which needs registers */
1083 !result->isspilt && /* and does not already have them */
1085 !bitVectBitValue (_G.regAssigned, result->key) &&
1086 /* the number of free regs + number of regs in this LR
1087 can accomodate the what result Needs */
1088 ((nfreeRegsType (result->regType) +
1089 sym->nRegs) >= result->nRegs)
1093 for (i = 0; i < result->nRegs; i++)
1095 result->regs[i] = sym->regs[i];
1097 result->regs[i] = getRegGpr (ic, ebp, result);
1099 _G.regAssigned = bitVectSetBit (_G.regAssigned, result->key);
1100 _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, result->key);
1104 /* free the remaining */
1105 for (; i < sym->nRegs; i++)
1109 if (!symHasReg (psym, sym->regs[i]))
1110 freeReg (sym->regs[i]);
1113 freeReg (sym->regs[i]);
1120 /*-----------------------------------------------------------------*/
1121 /* reassignLR - reassign this to registers */
1122 /*-----------------------------------------------------------------*/
1124 reassignLR (operand * op)
1126 symbol *sym = OP_SYMBOL (op);
1129 /* not spilt any more */
1130 sym->isspilt = sym->spillA = sym->blockSpil = sym->remainSpil = 0;
1131 bitVectUnSetBit (_G.spiltSet, sym->key);
1133 _G.regAssigned = bitVectSetBit (_G.regAssigned, sym->key);
1134 _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, sym->key);
1138 for (i = 0; i < sym->nRegs; i++)
1139 sym->regs[i]->isFree = 0;
1142 /*-----------------------------------------------------------------*/
1143 /* willCauseSpill - determines if allocating will cause a spill */
1144 /*-----------------------------------------------------------------*/
1146 willCauseSpill (int nr, int rt)
1148 /* first check if there are any available registers
1149 of the type required */
1152 /* special case for pointer type
1153 if pointer type not avlb then
1154 check for type gpr */
1155 if (nFreeRegs (rt) >= nr)
1157 if (nFreeRegs (REG_GPR) >= nr)
1160 else if (rt == REG_BIT)
1162 if (nFreeRegs (rt) >= nr)
1167 if (mcs51_ptrRegReq)
1169 if (nFreeRegs (rt) >= nr)
1174 if (nFreeRegs (REG_PTR) +
1175 nFreeRegs (REG_GPR) >= nr)
1180 /* it will cause a spil */
1184 /*-----------------------------------------------------------------*/
1185 /* positionRegs - the allocator can allocate same registers to res- */
1186 /* ult and operand, if this happens make sure they are in the same */
1187 /* position as the operand otherwise chaos results */
1188 /*-----------------------------------------------------------------*/
1190 positionRegs (symbol * result, symbol * opsym)
1192 int count = min (result->nRegs, opsym->nRegs);
1193 int i, j = 0, shared = 0;
1196 /* if the result has been spilt then cannot share */
1201 /* first make sure that they actually share */
1202 for (i = 0; i < count; i++)
1204 for (j = 0; j < count; j++)
1206 if (result->regs[i] == opsym->regs[j] && i != j)
1216 regs *tmp = result->regs[i];
1217 result->regs[i] = result->regs[j];
1218 result->regs[j] = tmp;
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++)
1264 if (ebbs[i]->noPath &&
1265 (ebbs[i]->entryLabel != entryLabel &&
1266 ebbs[i]->entryLabel != returnLabel))
1269 /* for all instructions do */
1270 for (ic = ebbs[i]->sch; ic; ic = ic->next)
1274 /* if this is an ipop that means some live
1275 range will have to be assigned again */
1277 reassignLR (IC_LEFT (ic));
1279 /* if result is present && is a true symbol */
1280 if (IC_RESULT (ic) && ic->op != IFX &&
1281 IS_TRUE_SYMOP (IC_RESULT (ic)))
1282 OP_SYMBOL (IC_RESULT (ic))->allocreq++;
1284 /* take away registers from live
1285 ranges that end at this instruction */
1286 deassignLRs (ic, ebbs[i]);
1288 /* some don't need registers */
1289 if (SKIP_IC2 (ic) ||
1290 ic->op == JUMPTABLE ||
1294 (IC_RESULT (ic) && POINTER_SET (ic)))
1297 /* now we need to allocate registers
1298 only for the result */
1299 if (IC_RESULT (ic)) {
1300 symbol *sym = OP_SYMBOL (IC_RESULT (ic));
1306 /* Make sure any spill location is definitely allocated */
1307 if (sym->isspilt && !sym->remat && sym->usl.spillLoc &&
1308 !sym->usl.spillLoc->allocreq)
1310 sym->usl.spillLoc->allocreq++;
1313 /* if it does not need or is spilt
1314 or is already assigned to registers
1315 or will not live beyond this instructions */
1318 bitVectBitValue (_G.regAssigned, sym->key) ||
1319 sym->liveTo <= ic->seq)
1322 /* if some liverange has been spilt at the block level
1323 and this one live beyond this block then spil this
1325 if (_G.blockSpil && sym->liveTo > ebbs[i]->lSeq) {
1330 willCS = willCauseSpill (sym->nRegs, sym->regType);
1331 /* if this is a bit variable then don't use precious registers
1332 along with expensive bit-to-char conversions but just spill
1334 if (willCS && SPEC_NOUN(sym->etype) == V_BIT) {
1339 /* if trying to allocate this will cause
1340 a spill and there is nothing to spill
1341 or this one is rematerializable then
1343 spillable = computeSpillable (ic);
1344 if (sym->remat || (willCS && bitVectIsZero (spillable))) {
1349 /* If the live range preceeds the point of definition
1350 then ideally we must take into account registers that
1351 have been allocated after sym->liveFrom but freed
1352 before ic->seq. This is complicated, so spill this
1353 symbol instead and let fillGaps handle the allocation. */
1354 if (sym->liveFrom < ic->seq) {
1359 /* if it has a spillocation & is used less than
1360 all other live ranges then spill this */
1362 if (sym->usl.spillLoc) {
1363 symbol *leastUsed = leastUsedLR (liveRangesWith (spillable,
1364 allLRs, ebbs[i], ic));
1365 if (leastUsed && leastUsed->used > sym->used) {
1370 /* if none of the liveRanges have a spillLocation then better
1371 to spill this one than anything else already assigned to registers */
1372 if (liveRangesWith(spillable,noSpilLoc,ebbs[i],ic)) {
1373 /* if this is local to this block then we might find a block spil */
1374 if (!(sym->liveFrom >= ebbs[i]->fSeq && sym->liveTo <= ebbs[i]->lSeq)) {
1381 /* if we need ptr regs for the right side
1383 if (POINTER_GET (ic) && IS_SYMOP (IC_LEFT (ic))
1384 && getSize (OP_SYMBOL (IC_LEFT (ic))->type) <= (unsigned int) PTRSIZE) {
1388 if (IC_LEFT (ic) && IS_SYMOP (IC_LEFT (ic))
1389 && SPEC_OCLS(OP_SYMBOL (IC_LEFT (ic))->etype) == idata) {
1393 if (IC_RIGHT (ic) && IS_SYMOP (IC_RIGHT (ic))
1394 && SPEC_OCLS(OP_SYMBOL (IC_RIGHT (ic))->etype) == idata) {
1399 /* else we assign registers to it */
1400 _G.regAssigned = bitVectSetBit (_G.regAssigned, sym->key);
1401 _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, sym->key);
1403 for (j = 0; j < sym->nRegs; j++) {
1404 sym->regs[j] = NULL;
1405 if (sym->regType == REG_PTR)
1406 sym->regs[j] = getRegPtr (ic, ebbs[i], sym);
1407 else if (sym->regType == REG_BIT)
1408 sym->regs[j] = getRegBit (sym);
1411 if (ic->op == CAST && IS_SYMOP (IC_RIGHT (ic)))
1413 symbol * right = OP_SYMBOL (IC_RIGHT (ic));
1415 if (right->regs[j] && (right->regType != REG_BIT))
1416 sym->regs[j] = allocThisReg (right->regs[j]);
1419 sym->regs[j] = getRegGpr (ic, ebbs[i], sym);
1422 /* if the allocation failed which means
1423 this was spilt then break */
1427 for (i=0; i < sym->nRegs ; i++ )
1428 sym->regs[i] = NULL;
1433 if (!POINTER_SET(ic) && !POINTER_GET(ic)) {
1434 /* if it shares registers with operands make sure
1435 that they are in the same position */
1436 if (IC_LEFT (ic) && IS_SYMOP (IC_LEFT (ic)) &&
1437 OP_SYMBOL (IC_LEFT (ic))->nRegs) {
1438 positionRegs (OP_SYMBOL (IC_RESULT (ic)),
1439 OP_SYMBOL (IC_LEFT (ic)));
1441 /* do the same for the right operand */
1442 if (IC_RIGHT (ic) && IS_SYMOP (IC_RIGHT (ic)) &&
1443 OP_SYMBOL (IC_RIGHT (ic))->nRegs) {
1444 positionRegs (OP_SYMBOL (IC_RESULT (ic)),
1445 OP_SYMBOL (IC_RIGHT (ic)));
1458 /* Check for and fix any problems with uninitialized operands */
1459 for (i = 0; i < count; i++)
1463 if (ebbs[i]->noPath &&
1464 (ebbs[i]->entryLabel != entryLabel &&
1465 ebbs[i]->entryLabel != returnLabel))
1468 for (ic = ebbs[i]->sch; ic; ic = ic->next)
1475 verifyRegsAssigned (IC_COND (ic), ic);
1479 if (ic->op == JUMPTABLE)
1481 verifyRegsAssigned (IC_JTCOND (ic), ic);
1485 verifyRegsAssigned (IC_RESULT (ic), ic);
1486 verifyRegsAssigned (IC_LEFT (ic), ic);
1487 verifyRegsAssigned (IC_RIGHT (ic), ic);
1492 /*-----------------------------------------------------------------*/
1493 /* fillGaps - Try to fill in the Gaps left by Pass1 */
1494 /*-----------------------------------------------------------------*/
1495 static void fillGaps()
1502 if (getenv("DISABLE_FILL_GAPS")) return;
1504 /* look for liveranges that were spilt by the allocator */
1505 for (sym = hTabFirstItem(liveRanges,&key) ; sym ;
1506 sym = hTabNextItem(liveRanges,&key)) {
1511 if (!sym->spillA || !sym->clashes || sym->remat) continue ;
1513 /* if spilt in direct space the original rname is lost */
1514 if (sym->usl.spillLoc && (IN_DIRSPACE (SPEC_OCLS (sym->usl.spillLoc->etype))))
1517 /* find the liveRanges this one clashes with, that are
1518 still assigned to registers & mark the registers as used*/
1519 for ( i = 0 ; i < sym->clashes->size ; i ++) {
1523 if (bitVectBitValue(sym->clashes,i) == 0 || /* those that clash with this */
1524 bitVectBitValue(_G.totRegAssigned,i) == 0) /* and are still assigned to registers */
1527 clr = hTabItemWithKey(liveRanges,i);
1530 /* mark these registers as used */
1531 for (k = 0 ; k < clr->nRegs ; k++ )
1532 useReg(clr->regs[k]);
1535 if (willCauseSpill(sym->nRegs,sym->regType)) {
1536 /* NOPE :( clear all registers & and continue */
1542 for (i = 0 ; i < sym->defs->size ; i++ )
1544 if (bitVectBitValue(sym->defs,i))
1546 if (!(ic = hTabItemWithKey(iCodehTab,i)))
1553 D(printf("Attempting fillGaps on %s: [",sym->name));
1554 /* THERE IS HOPE !!!! */
1555 for (i=0; i < sym->nRegs ; i++ ) {
1556 if (sym->regType == REG_PTR)
1557 sym->regs[i] = getRegPtrNoSpil ();
1558 else if (sym->regType == REG_BIT)
1559 sym->regs[i] = getRegBitNoSpil ();
1562 sym->regs[i] = NULL;
1563 if (ic && ic->op == CAST && IS_SYMOP (IC_RIGHT (ic)))
1565 symbol * right = OP_SYMBOL (IC_RIGHT (ic));
1568 sym->regs[i] = allocThisReg (right->regs[i]);
1571 sym->regs[i] = getRegGprNoSpil ();
1573 D(printf("%s ", sym->regs[i]->name));
1577 /* For all its definitions check if the registers
1578 allocated needs positioning NOTE: we can position
1579 only ONCE if more than One positioning required
1581 We may need to perform the checks twice; once to
1582 position the registers as needed, the second to
1583 verify any register repositioning is still
1587 for (pass=0; pass<2; pass++) {
1588 D(printf(" checking definitions\n"));
1589 for (i = 0 ; i < sym->defs->size ; i++ ) {
1590 if (bitVectBitValue(sym->defs,i)) {
1591 if (!(ic = hTabItemWithKey(iCodehTab,i))) continue ;
1592 D(printf(" ic->seq = %d\n", ic->seq));
1593 if (SKIP_IC(ic)) continue;
1594 assert(isSymbolEqual(sym,OP_SYMBOL(IC_RESULT(ic)))); /* just making sure */
1595 /* if left is assigned to registers */
1596 if (IS_SYMOP(IC_LEFT(ic)))
1598 D(printf(" left = "));
1599 D(printOperand(IC_LEFT(ic),NULL));
1601 if (IS_SYMOP(IC_LEFT(ic)) &&
1602 bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_LEFT(ic))->key)) {
1603 pdone += (positionRegs(sym,OP_SYMBOL(IC_LEFT(ic)))>0);
1605 if (IS_SYMOP(IC_RIGHT(ic)))
1607 D(printf(" right = "));
1608 D(printOperand(IC_RIGHT(ic),NULL));
1610 if (IS_SYMOP(IC_RIGHT(ic)) &&
1611 bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_RIGHT(ic))->key)) {
1612 pdone += (positionRegs(sym,OP_SYMBOL(IC_RIGHT(ic)))>0);
1614 D(printf(" pdone = %d\n", pdone));
1615 if (pdone > 1) break;
1618 D(printf(" checking uses\n"));
1619 for (i = 0 ; i < sym->uses->size ; i++ ) {
1620 if (bitVectBitValue(sym->uses,i)) {
1622 if (!(ic = hTabItemWithKey(iCodehTab,i))) continue ;
1623 D(printf(" ic->seq = %d\n", ic->seq));
1624 if (SKIP_IC(ic)) continue;
1625 if (POINTER_SET(ic) || POINTER_GET(ic)) continue ;
1627 /* if result is assigned to registers */
1628 if (IS_SYMOP(IC_RESULT(ic)))
1630 D(printf(" result = "));
1631 D(printOperand(IC_RESULT(ic),NULL));
1633 if (IS_SYMOP(IC_RESULT(ic)) &&
1634 bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_RESULT(ic))->key)) {
1635 pdone += (positionRegs(sym,OP_SYMBOL(IC_RESULT(ic)))>0);
1637 D(printf(" pdone = %d\n", pdone));
1638 if (pdone > 1) break;
1641 if (pdone == 0) break; /* second pass only if regs repositioned */
1642 if (pdone > 1) break;
1644 D(printf(" sym->regs = ["));
1645 for (i=0; i < sym->nRegs ; i++ )
1646 D(printf("%s ", sym->regs[i]->name));
1648 /* had to position more than once GIVE UP */
1650 /* UNDO all the changes we made to try this */
1652 for (i=0; i < sym->nRegs ; i++ ) {
1653 sym->regs[i] = NULL;
1656 D(printf ("Fill Gap gave up due to positioning for %s in function %s\n",sym->name, currFunc ? currFunc->name : "UNKNOWN"));
1659 D(printf ("FILLED GAP for %s in function %s\n",sym->name, currFunc ? currFunc->name : "UNKNOWN"));
1661 _G.totRegAssigned = bitVectSetBit(_G.totRegAssigned,sym->key);
1662 sym->isspilt = sym->spillA = 0 ;
1663 sym->usl.spillLoc->allocreq--;
1668 /*-----------------------------------------------------------------*/
1669 /* findAllBitregs :- returns bit vector of all bit registers */
1670 /*-----------------------------------------------------------------*/
1672 findAllBitregs (void)
1674 bitVect *rmask = newBitVect (mcs51_nRegs);
1677 for (j = 0; j < mcs51_nRegs; j++)
1679 if (regs8051[j].type == REG_BIT)
1680 rmask = bitVectSetBit (rmask, regs8051[j].rIdx);
1686 /*-----------------------------------------------------------------*/
1687 /* mcs51_allBitregs :- returns bit vector of all bit registers */
1688 /*-----------------------------------------------------------------*/
1690 mcs51_allBitregs (void)
1692 return _G.allBitregs;
1695 /*-----------------------------------------------------------------*/
1696 /* rUmaskForOp :- returns register mask for an operand */
1697 /*-----------------------------------------------------------------*/
1699 mcs51_rUmaskForOp (operand * op)
1705 /* only temporaries are assigned registers */
1709 sym = OP_SYMBOL (op);
1711 /* if spilt or no registers assigned to it
1713 if (sym->isspilt || !sym->nRegs)
1716 rumask = newBitVect (mcs51_nRegs);
1718 for (j = 0; j < sym->nRegs; j++)
1720 if (sym->regs[j]) /* EEP - debug */
1721 rumask = bitVectSetBit (rumask, sym->regs[j]->rIdx);
1727 /*-----------------------------------------------------------------*/
1728 /* regsUsedIniCode :- returns bit vector of registers used in iCode */
1729 /*-----------------------------------------------------------------*/
1731 regsUsedIniCode (iCode * ic)
1733 bitVect *rmask = newBitVect (mcs51_nRegs);
1735 /* do the special cases first */
1738 rmask = bitVectUnion (rmask,
1739 mcs51_rUmaskForOp (IC_COND (ic)));
1743 /* for the jumptable */
1744 if (ic->op == JUMPTABLE)
1746 rmask = bitVectUnion (rmask,
1747 mcs51_rUmaskForOp (IC_JTCOND (ic)));
1752 /* of all other cases */
1754 rmask = bitVectUnion (rmask,
1755 mcs51_rUmaskForOp (IC_LEFT (ic)));
1759 rmask = bitVectUnion (rmask,
1760 mcs51_rUmaskForOp (IC_RIGHT (ic)));
1763 rmask = bitVectUnion (rmask,
1764 mcs51_rUmaskForOp (IC_RESULT (ic)));
1770 /*-----------------------------------------------------------------*/
1771 /* createRegMask - for each instruction will determine the regsUsed */
1772 /*-----------------------------------------------------------------*/
1774 createRegMask (eBBlock ** ebbs, int count)
1778 /* for all blocks */
1779 for (i = 0; i < count; i++)
1783 if (ebbs[i]->noPath &&
1784 (ebbs[i]->entryLabel != entryLabel &&
1785 ebbs[i]->entryLabel != returnLabel))
1788 /* for all instructions */
1789 for (ic = ebbs[i]->sch; ic; ic = ic->next)
1794 if (SKIP_IC2 (ic) || !ic->rlive)
1797 /* first mark the registers used in this
1799 ic->rUsed = regsUsedIniCode (ic);
1800 _G.funcrUsed = bitVectUnion (_G.funcrUsed, ic->rUsed);
1802 /* now create the register mask for those
1803 registers that are in use : this is a
1804 super set of ic->rUsed */
1805 ic->rMask = newBitVect (mcs51_nRegs + 1);
1807 /* for all live Ranges alive at this point */
1808 for (j = 1; j < ic->rlive->size; j++)
1813 /* if not alive then continue */
1814 if (!bitVectBitValue (ic->rlive, j))
1817 /* find the live range we are interested in */
1818 if (!(sym = hTabItemWithKey (liveRanges, j)))
1820 werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
1821 "createRegMask cannot find live range");
1822 fprintf(stderr, "\tmissing live range: key=%d\n", j);
1826 /* if no register assigned to it */
1827 if (!sym->nRegs || sym->isspilt)
1830 /* for all the registers allocated to it */
1831 for (k = 0; k < sym->nRegs; k++)
1834 bitVectSetBit (ic->rMask, sym->regs[k]->rIdx);
1840 /*-----------------------------------------------------------------*/
1841 /* rematStr - returns the rematerialized string for a remat var */
1842 /*-----------------------------------------------------------------*/
1844 rematStr (symbol * sym)
1846 iCode *ic = sym->rematiCode;
1851 /* if plus adjust offset to right hand side */
1854 offset += (int) operandLitValue (IC_RIGHT (ic));
1855 ic = OP_SYMBOL (IC_LEFT (ic))->rematiCode;
1859 /* if minus adjust offset to right hand side */
1862 offset -= (int) operandLitValue (IC_RIGHT (ic));
1863 ic = OP_SYMBOL (IC_LEFT (ic))->rematiCode;
1867 /* cast then continue */
1868 if (IS_CAST_ICODE(ic)) {
1869 ic = OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
1872 /* we reached the end */
1878 SNPRINTF (buffer, sizeof(buffer),
1880 OP_SYMBOL (IC_LEFT (ic))->rname,
1881 offset >= 0 ? '+' : '-',
1882 abs (offset) & 0xffff);
1886 strncpyz (buffer, OP_SYMBOL (IC_LEFT (ic))->rname, sizeof(buffer));
1891 /*-----------------------------------------------------------------*/
1892 /* regTypeNum - computes the type & number of registers required */
1893 /*-----------------------------------------------------------------*/
1895 regTypeNum (eBBlock *ebbs)
1901 /* for each live range do */
1902 for (sym = hTabFirstItem (liveRanges, &k); sym;
1903 sym = hTabNextItem (liveRanges, &k))
1906 /* if used zero times then no registers needed */
1907 if ((sym->liveTo - sym->liveFrom) == 0)
1911 /* if the live range is a temporary */
1915 /* if the type is marked as a conditional */
1916 if (sym->regType == REG_CND)
1919 /* if used in return only then we don't
1921 if (sym->ruonly || sym->accuse)
1923 if (IS_AGGREGATE (sym->type) || sym->isptr)
1924 sym->type = aggrToPtr (sym->type, FALSE);
1925 else if (IS_BIT(sym->type))
1926 sym->regType = REG_CND;
1930 /* if the symbol has only one definition &
1931 that definition is a get_pointer */
1932 if (bitVectnBitsOn (sym->defs) == 1 &&
1933 (ic = hTabItemWithKey (iCodehTab,
1934 bitVectFirstBit (sym->defs))) &&
1936 !IS_BITVAR (sym->etype) &&
1937 (aggrToPtrDclType (operandType (IC_LEFT (ic)), FALSE) == POINTER))
1940 if (ptrPseudoSymSafe (sym, ic))
1942 ptrPseudoSymConvert (sym, ic, rematStr (OP_SYMBOL (IC_LEFT (ic))));
1946 /* if in data space or idata space then try to
1947 allocate pointer register */
1951 /* if not then we require registers */
1952 sym->nRegs = ((IS_AGGREGATE (sym->type) || sym->isptr) ?
1953 getSize (sym->type = aggrToPtr (sym->type, FALSE)) :
1954 getSize (sym->type));
1958 fprintf (stderr, "allocated more than 4 or 0 registers for type ");
1959 printTypeChain (sym->type, stderr);
1960 fprintf (stderr, "\n");
1963 /* determine the type of register required */
1964 if (sym->nRegs == 1 && IS_PTR (sym->type) && sym->uptr)
1965 sym->regType = REG_PTR;
1966 else if (IS_BIT(sym->type))
1967 sym->regType = REG_BIT;
1969 sym->regType = REG_GPR;
1972 /* for the first run we don't provide */
1973 /* registers for true symbols we will */
1974 /* see how things go */
1980 /*-----------------------------------------------------------------*/
1981 /* freeAllRegs - mark all registers as free */
1982 /*-----------------------------------------------------------------*/
1988 for (i = 0; i < mcs51_nRegs; i++)
1989 regs8051[i].isFree = 1;
1992 /*-----------------------------------------------------------------*/
1993 /* deallocStackSpil - this will set the stack pointer back */
1994 /*-----------------------------------------------------------------*/
1996 DEFSETFUNC (deallocStackSpil)
2004 /*-----------------------------------------------------------------*/
2005 /* farSpacePackable - returns the packable icode for far variables */
2006 /*-----------------------------------------------------------------*/
2008 farSpacePackable (iCode * ic)
2012 /* go thru till we find a definition for the
2013 symbol on the right */
2014 for (dic = ic->prev; dic; dic = dic->prev)
2016 /* if the definition is a call then no */
2017 if ((dic->op == CALL || dic->op == PCALL) &&
2018 IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
2023 /* if shift by unknown amount then not */
2024 if ((dic->op == LEFT_OP || dic->op == RIGHT_OP) &&
2025 IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
2028 /* if pointer get and size > 1 */
2029 if (POINTER_GET (dic) &&
2030 getSize (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)) > 1)
2033 if (POINTER_SET (dic) &&
2034 getSize (aggrToPtr (operandType (IC_RESULT (dic)), FALSE)) > 1)
2039 if (IC_COND (dic) &&
2040 IS_TRUE_SYMOP (IC_COND (dic)) &&
2041 isOperandInFarSpace (IC_COND (dic)))
2044 else if (dic->op == JUMPTABLE)
2046 if (IC_JTCOND (dic) &&
2047 IS_TRUE_SYMOP (IC_JTCOND (dic)) &&
2048 isOperandInFarSpace (IC_JTCOND (dic)))
2053 /* if any tree is a true symbol in far space */
2054 if (IC_RESULT (dic) &&
2055 IS_TRUE_SYMOP (IC_RESULT (dic)) &&
2056 isOperandInFarSpace (IC_RESULT (dic)))
2059 if (IC_RIGHT (dic) &&
2060 IS_TRUE_SYMOP (IC_RIGHT (dic)) &&
2061 isOperandInFarSpace (IC_RIGHT (dic)) &&
2062 !isOperandEqual (IC_RIGHT (dic), IC_RESULT (ic)))
2065 if (IC_LEFT (dic) &&
2066 IS_TRUE_SYMOP (IC_LEFT (dic)) &&
2067 isOperandInFarSpace (IC_LEFT (dic)) &&
2068 !isOperandEqual (IC_LEFT (dic), IC_RESULT (ic)))
2072 if (isOperandEqual (IC_RIGHT (ic), IC_RESULT (dic)))
2074 if ((dic->op == LEFT_OP ||
2075 dic->op == RIGHT_OP ||
2077 IS_OP_LITERAL (IC_RIGHT (dic)))
2087 /*-----------------------------------------------------------------*/
2088 /* packRegsForAssign - register reduction for assignment */
2089 /*-----------------------------------------------------------------*/
2091 packRegsForAssign (iCode * ic, eBBlock * ebp)
2095 if (!IS_ITEMP (IC_RIGHT (ic)) ||
2096 OP_SYMBOL (IC_RIGHT (ic))->isind ||
2097 OP_LIVETO (IC_RIGHT (ic)) > ic->seq)
2102 /* if the true symbol is defined in far space or on stack
2103 then we should not since this will increase register pressure */
2104 if (isOperandInFarSpace(IC_RESULT(ic)) && !farSpacePackable(ic)) {
2108 /* find the definition of iTempNN scanning backwards if we find a
2109 a use of the true symbol in before we find the definition then
2111 for (dic = ic->prev; dic; dic = dic->prev)
2113 int crossedCall = 0;
2115 /* We can pack across a function call only if it's a local */
2116 /* variable or our parameter. Never pack global variables */
2117 /* or parameters to a function we call. */
2118 if ((dic->op == CALL || dic->op == PCALL))
2120 if (!OP_SYMBOL (IC_RESULT (ic))->ismyparm
2121 && !OP_SYMBOL (IC_RESULT (ic))->islocal)
2127 /* Don't move an assignment out of a critical block */
2128 if (dic->op == CRITICAL)
2139 if (IS_SYMOP (IC_COND (dic)) &&
2140 (IC_COND (dic)->key == IC_RESULT (ic)->key ||
2141 IC_COND (dic)->key == IC_RIGHT (ic)->key))
2149 if (IS_TRUE_SYMOP (IC_RESULT (dic)) &&
2150 IS_OP_VOLATILE (IC_RESULT (dic)))
2156 if (IS_SYMOP (IC_RESULT (dic)) &&
2157 IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
2159 if (POINTER_SET (dic))
2165 if (IS_SYMOP (IC_RIGHT (dic)) &&
2166 (IC_RIGHT (dic)->key == IC_RESULT (ic)->key ||
2167 IC_RIGHT (dic)->key == IC_RIGHT (ic)->key))
2173 if (IS_SYMOP (IC_LEFT (dic)) &&
2174 (IC_LEFT (dic)->key == IC_RESULT (ic)->key ||
2175 IC_LEFT (dic)->key == IC_RIGHT (ic)->key))
2181 if (IS_SYMOP (IC_RESULT (dic)) &&
2182 IC_RESULT (dic)->key == IC_RESULT (ic)->key)
2198 return 0; /* did not find */
2200 /* if assignment then check that right is not a bit */
2201 if (ASSIGNMENT (ic) && !POINTER_SET (ic))
2203 sym_link *etype = operandType (IC_RESULT (dic));
2204 if (IS_BITFIELD (etype))
2206 /* if result is a bit too then it's ok */
2207 etype = operandType (IC_RESULT (ic));
2208 if (!IS_BITFIELD (etype))
2215 /* if the result is on stack or iaccess then it must be
2216 the same atleast one of the operands */
2217 if (OP_SYMBOL (IC_RESULT (ic))->onStack ||
2218 OP_SYMBOL (IC_RESULT (ic))->iaccess)
2221 /* the operation has only one symbol
2222 operator then we can pack */
2223 if ((IC_LEFT (dic) && !IS_SYMOP (IC_LEFT (dic))) ||
2224 (IC_RIGHT (dic) && !IS_SYMOP (IC_RIGHT (dic))))
2227 if (!((IC_LEFT (dic) &&
2228 IC_RESULT (ic)->key == IC_LEFT (dic)->key) ||
2230 IC_RESULT (ic)->key == IC_RIGHT (dic)->key)))
2234 /* found the definition */
2235 /* replace the result with the result of */
2236 /* this assignment and remove this assignment */
2237 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2238 ReplaceOpWithCheaperOp(&IC_RESULT (dic), IC_RESULT (ic));
2240 if (IS_ITEMP (IC_RESULT (dic)) && OP_SYMBOL (IC_RESULT (dic))->liveFrom > dic->seq)
2242 OP_SYMBOL (IC_RESULT (dic))->liveFrom = dic->seq;
2244 // TODO: and the otherway around?
2246 /* delete from liverange table also
2247 delete from all the points inbetween and the new
2249 for (sic = dic; sic != ic; sic = sic->next)
2251 bitVectUnSetBit (sic->rlive, IC_RESULT (ic)->key);
2252 if (IS_ITEMP (IC_RESULT (dic)))
2253 bitVectSetBit (sic->rlive, IC_RESULT (dic)->key);
2256 remiCodeFromeBBlock (ebp, ic);
2257 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
2258 hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
2259 OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
2263 /*------------------------------------------------------------------*/
2264 /* findAssignToSym : scanning backwards looks for first assig found */
2265 /*------------------------------------------------------------------*/
2267 findAssignToSym (operand * op, iCode * ic)
2271 /* This routine is used to find sequences like
2273 ...; (intervening ops don't use iTempAA or modify FOO)
2274 blah = blah + iTempAA;
2276 and eliminate the use of iTempAA, freeing up its register for
2280 for (dic = ic->prev; dic; dic = dic->prev)
2283 /* if definition by assignment */
2284 if (dic->op == '=' &&
2285 !POINTER_SET (dic) &&
2286 IC_RESULT (dic)->key == op->key
2287 /* && IS_TRUE_SYMOP(IC_RIGHT(dic)) */
2289 break; /* found where this temp was defined */
2291 /* if we find an usage then we cannot delete it */
2295 if (IC_COND (dic) && IC_COND (dic)->key == op->key)
2298 else if (dic->op == JUMPTABLE)
2300 if (IC_JTCOND (dic) && IC_JTCOND (dic)->key == op->key)
2305 if (IC_LEFT (dic) && IC_LEFT (dic)->key == op->key)
2308 if (IC_RIGHT (dic) && IC_RIGHT (dic)->key == op->key)
2311 if (POINTER_SET (dic) && IC_RESULT (dic)->key == op->key)
2317 return NULL; /* didn't find any assignment to op */
2319 /* we are interested only if defined in far space */
2320 /* or in stack space in case of + & - */
2322 /* if assigned to a non-symbol then don't repack regs */
2323 if (!IS_SYMOP (IC_RIGHT (dic)))
2326 /* if the symbol is volatile then we should not */
2327 if (isOperandVolatile (IC_RIGHT (dic), TRUE))
2329 /* XXX TODO --- should we be passing FALSE to isOperandVolatile()?
2330 What does it mean for an iTemp to be volatile, anyway? Passing
2331 TRUE is more cautious but may prevent possible optimizations */
2333 /* if the symbol is in far space then we should not */
2334 if (isOperandInFarSpace (IC_RIGHT (dic)))
2337 /* for + & - operations make sure that
2338 if it is on the stack it is the same
2339 as one of the three operands */
2340 if ((ic->op == '+' || ic->op == '-') &&
2341 OP_SYMBOL (IC_RIGHT (dic))->onStack)
2344 if (IC_RESULT (ic)->key != IC_RIGHT (dic)->key &&
2345 IC_LEFT (ic)->key != IC_RIGHT (dic)->key &&
2346 IC_RIGHT (ic)->key != IC_RIGHT (dic)->key)
2350 /* now make sure that the right side of dic
2351 is not defined between ic & dic */
2354 iCode *sic = dic->next;
2356 for (; sic != ic; sic = sic->next)
2357 if (IC_RESULT (sic) &&
2358 IC_RESULT (sic)->key == IC_RIGHT (dic)->key)
2365 /*-----------------------------------------------------------------*/
2366 /* reassignAliasedSym - used by packRegsForSupport to replace */
2367 /* redundant iTemp with equivalent symbol */
2368 /*-----------------------------------------------------------------*/
2370 reassignAliasedSym (eBBlock *ebp, iCode *assignment, iCode *use, operand *op)
2373 unsigned oldSymKey, newSymKey;
2375 oldSymKey = op->key;
2376 newSymKey = IC_RIGHT(assignment)->key;
2378 /* only track live ranges of compiler-generated temporaries */
2379 if (!IS_ITEMP(IC_RIGHT(assignment)))
2382 /* update the live-value bitmaps */
2383 for (ic = assignment; ic != use; ic = ic->next) {
2384 bitVectUnSetBit (ic->rlive, oldSymKey);
2386 ic->rlive = bitVectSetBit (ic->rlive, newSymKey);
2389 /* update the sym of the used operand */
2390 OP_SYMBOL(op) = OP_SYMBOL(IC_RIGHT(assignment));
2391 op->key = OP_SYMBOL(op)->key;
2392 OP_SYMBOL(op)->accuse = 0;
2394 /* update the sym's liverange */
2395 if ( OP_LIVETO(op) < ic->seq )
2396 setToRange(op, ic->seq, FALSE);
2398 /* remove the assignment iCode now that its result is unused */
2399 remiCodeFromeBBlock (ebp, assignment);
2400 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(assignment))->defs, assignment->key);
2401 hTabDeleteItem (&iCodehTab, assignment->key, assignment, DELETE_ITEM, NULL);
2405 /*-----------------------------------------------------------------*/
2406 /* packRegsForSupport :- reduce some registers for support calls */
2407 /*-----------------------------------------------------------------*/
2409 packRegsForSupport (iCode * ic, eBBlock * ebp)
2413 /* for the left & right operand :- look to see if the
2414 left was assigned a true symbol in far space in that
2415 case replace them */
2417 if (IS_ITEMP (IC_LEFT (ic)) &&
2418 OP_SYMBOL (IC_LEFT (ic))->liveTo <= ic->seq)
2420 dic = findAssignToSym (IC_LEFT (ic), ic);
2424 /* found it we need to remove it from the block */
2425 reassignAliasedSym (ebp, dic, ic, IC_LEFT(ic));
2430 /* do the same for the right operand */
2431 if (IS_ITEMP (IC_RIGHT (ic)) &&
2432 OP_SYMBOL (IC_RIGHT (ic))->liveTo <= ic->seq)
2434 iCode *dic = findAssignToSym (IC_RIGHT (ic), ic);
2438 /* if this is a subtraction & the result
2439 is a true symbol in far space then don't pack */
2440 if (ic->op == '-' && IS_TRUE_SYMOP (IC_RESULT (dic)))
2442 sym_link *etype = getSpec (operandType (IC_RESULT (dic)));
2443 if (IN_FARSPACE (SPEC_OCLS (etype)))
2446 /* found it we need to remove it from the
2448 reassignAliasedSym (ebp, dic, ic, IC_RIGHT(ic));
2458 /*-----------------------------------------------------------------*/
2459 /* packRegsForOneuse : - will reduce some registers for single Use */
2460 /*-----------------------------------------------------------------*/
2462 packRegsForOneuse (iCode * ic, operand * op, eBBlock * ebp)
2466 /* if returning a literal then do nothing */
2470 /* if rematerializable or already return use then do nothing */
2471 if (OP_SYMBOL(op)->remat || OP_SYMBOL(op)->ruonly)
2474 /* only upto 2 bytes since we cannot predict
2475 the usage of b, & acc */
2476 if (getSize (operandType (op)) > (fReturnSizeMCS51 - 2))
2479 if (ic->op != RETURN &&
2481 !POINTER_SET (ic) &&
2485 if (ic->op == SEND && ic->argreg != 1) return NULL;
2487 /* this routine will mark the symbol as used in one
2488 instruction use only && if the definition is local
2489 (ie. within the basic block) && has only one definition &&
2490 that definition is either a return value from a
2491 function or does not contain any variables in
2493 if (bitVectnBitsOn (OP_USES (op)) > 1)
2496 /* if it has only one definition */
2497 if (bitVectnBitsOn (OP_DEFS (op)) > 1)
2498 return NULL; /* has more than one definition */
2500 /* get that definition */
2502 hTabItemWithKey (iCodehTab,
2503 bitVectFirstBit (OP_DEFS (op)))))
2506 /* if that only usage is a cast */
2507 if (dic->op == CAST) {
2508 /* to a bigger type */
2509 if (getSize(OP_SYM_TYPE(IC_RESULT(dic))) >
2510 getSize(OP_SYM_TYPE(IC_RIGHT(dic)))) {
2511 /* than we can not, since we cannot predict the usage of b & acc */
2516 /* found the definition now check if it is local */
2517 if (dic->seq < ebp->fSeq ||
2518 dic->seq > ebp->lSeq)
2519 return NULL; /* non-local */
2521 /* now check if it is the return from
2523 if (dic->op == CALL || dic->op == PCALL)
2525 if (ic->op != SEND && ic->op != RETURN &&
2526 !POINTER_SET(ic) && !POINTER_GET(ic))
2528 OP_SYMBOL (op)->ruonly = 1;
2534 /* otherwise check that the definition does
2535 not contain any symbols in far space */
2536 if (isOperandInFarSpace (IC_LEFT (dic)) ||
2537 isOperandInFarSpace (IC_RIGHT (dic)) ||
2538 IS_OP_RUONLY (IC_LEFT (ic)) ||
2539 IS_OP_RUONLY (IC_RIGHT (ic)))
2544 /* if pointer set then make sure the pointer
2546 if (POINTER_SET (dic) &&
2547 !IS_DATA_PTR (aggrToPtr (operandType (IC_RESULT (dic)), FALSE)))
2550 if (POINTER_GET (dic) &&
2551 !IS_DATA_PTR (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)))
2555 /* Make sure no overlapping liverange is already assigned to DPTR */
2556 if (OP_SYMBOL(op)->clashes)
2561 for (i = 0 ; i < OP_SYMBOL(op)->clashes->size ; i++ )
2563 if (bitVectBitValue(OP_SYMBOL(op)->clashes,i))
2565 sym = hTabItemWithKey(liveRanges,i);
2574 /* also make sure the intervening instructions
2575 don't have anything in far space */
2576 for (dic = dic->next; dic && dic != ic && sic != ic; dic = dic->next)
2578 /* if there is an intervening function call then no */
2579 if (dic->op == CALL || dic->op == PCALL)
2581 /* if pointer set then make sure the pointer
2583 if (POINTER_SET (dic) &&
2584 !IS_DATA_PTR (aggrToPtr (operandType (IC_RESULT (dic)), FALSE)))
2587 if (POINTER_GET (dic) &&
2588 !IS_DATA_PTR (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)))
2591 /* if address of & the result is remat the okay */
2592 if (dic->op == ADDRESS_OF &&
2593 OP_SYMBOL (IC_RESULT (dic))->remat)
2596 /* if operand has size of three or more & this
2597 operation is a '*','/' or '%' then 'b' may
2599 if ((dic->op == '%' || dic->op == '/' || dic->op == '*') &&
2600 getSize (operandType (op)) >= 3)
2603 /* if left or right or result is in far space */
2604 if (isOperandInFarSpace (IC_LEFT (dic)) ||
2605 isOperandInFarSpace (IC_RIGHT (dic)) ||
2606 isOperandInFarSpace (IC_RESULT (dic)) ||
2607 IS_OP_RUONLY (IC_LEFT (dic)) ||
2608 IS_OP_RUONLY (IC_RIGHT (dic)) ||
2609 IS_OP_RUONLY (IC_RESULT (dic)))
2613 /* if left or right or result is on stack */
2614 if (isOperandOnStack(IC_LEFT(dic)) ||
2615 isOperandOnStack(IC_RIGHT(dic)) ||
2616 isOperandOnStack(IC_RESULT(dic))) {
2621 OP_SYMBOL (op)->ruonly = 1;
2625 /*-----------------------------------------------------------------*/
2626 /* isBitwiseOptimizable - requirements of JEAN LOUIS VERN */
2627 /*-----------------------------------------------------------------*/
2629 isBitwiseOptimizable (iCode * ic)
2631 sym_link *ltype = getSpec (operandType (IC_LEFT (ic)));
2632 sym_link *rtype = getSpec (operandType (IC_RIGHT (ic)));
2634 /* bitwise operations are considered optimizable
2635 under the following conditions (Jean-Louis VERN)
2647 if (IS_LITERAL(rtype) ||
2648 (IS_BITVAR (ltype) && IN_BITSPACE (SPEC_OCLS (ltype))))
2654 /*-----------------------------------------------------------------*/
2655 /* isCommutativeOp - tests whether this op cares what order its */
2656 /* operands are in */
2657 /*-----------------------------------------------------------------*/
2658 bool isCommutativeOp(unsigned int op)
2660 if (op == '+' || op == '*' || op == EQ_OP ||
2661 op == '^' || op == '|' || op == BITWISEAND)
2667 /*-----------------------------------------------------------------*/
2668 /* operandUsesAcc - determines whether the code generated for this */
2669 /* operand will have to use the accumulator */
2670 /*-----------------------------------------------------------------*/
2671 bool operandUsesAcc(operand *op, bool allowBitspace)
2677 symbol *sym = OP_SYMBOL(op);
2681 return TRUE; /* duh! */
2683 if (IN_STACK(sym->etype) || sym->onStack ||
2684 (SPIL_LOC(op) && SPIL_LOC(op)->onStack))
2685 return TRUE; /* acc is used to calc stack offset */
2690 sym = SPIL_LOC(op); /* if spilled, look at spill location */
2692 return FALSE; /* more checks? */
2696 symspace = SPEC_OCLS(sym->etype);
2698 if (sym->iaccess && symspace->paged)
2699 return TRUE; /* must fetch paged indirect sym via accumulator */
2701 if (!allowBitspace && IN_BITSPACE(symspace))
2702 return TRUE; /* fetching bit vars uses the accumulator */
2704 if (IN_FARSPACE(symspace) || IN_CODESPACE(symspace))
2705 return TRUE; /* fetched via accumulator and dptr */
2711 /*-----------------------------------------------------------------*/
2712 /* packRegsForAccUse - pack registers for acc use */
2713 /*-----------------------------------------------------------------*/
2715 packRegsForAccUse (iCode * ic)
2719 /* if this is an aggregate, e.g. a one byte char array */
2720 if (IS_AGGREGATE(operandType(IC_RESULT(ic)))) {
2724 /* if we are calling a reentrant function that has stack parameters */
2725 if (ic->op == CALL &&
2726 IFFUNC_ISREENT(operandType(IC_LEFT(ic))) &&
2727 FUNC_HASSTACKPARM(operandType(IC_LEFT(ic))))
2730 if (ic->op == PCALL &&
2731 IFFUNC_ISREENT(operandType(IC_LEFT(ic))->next) &&
2732 FUNC_HASSTACKPARM(operandType(IC_LEFT(ic))->next))
2735 /* if + or - then it has to be one byte result */
2736 if ((ic->op == '+' || ic->op == '-')
2737 && getSize (operandType (IC_RESULT (ic))) > 1)
2740 /* if shift operation make sure right side is not a literal */
2741 if (ic->op == RIGHT_OP &&
2742 (isOperandLiteral (IC_RIGHT (ic)) ||
2743 getSize (operandType (IC_RESULT (ic))) > 1))
2746 if (ic->op == LEFT_OP &&
2747 (isOperandLiteral (IC_RIGHT (ic)) ||
2748 getSize (operandType (IC_RESULT (ic))) > 1))
2751 if (IS_BITWISE_OP (ic) &&
2752 getSize (operandType (IC_RESULT (ic))) > 1)
2755 /* has only one definition */
2756 if (bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) > 1)
2759 /* has only one use */
2760 if (bitVectnBitsOn (OP_USES (IC_RESULT (ic))) > 1)
2763 /* and the usage immediately follows this iCode */
2764 if (!(uic = hTabItemWithKey (iCodehTab,
2765 bitVectFirstBit (OP_USES (IC_RESULT (ic))))))
2768 if (ic->next != uic)
2771 /* if it is a conditional branch then we definitely can */
2775 if (uic->op == JUMPTABLE)
2778 if (POINTER_SET (uic) &&
2779 getSize (aggrToPtr (operandType (IC_RESULT (uic)), FALSE)) > 1)
2782 /* if the usage is not an assignment
2783 or an arithmetic / bitwise / shift operation then not */
2784 if (uic->op != '=' &&
2785 !IS_ARITHMETIC_OP (uic) &&
2786 !IS_BITWISE_OP (uic) &&
2787 uic->op != LEFT_OP &&
2788 uic->op != RIGHT_OP)
2791 /* if used in ^ operation then make sure right is not a
2792 literal (WIML: Why is this?) */
2793 if (uic->op == '^' && isOperandLiteral (IC_RIGHT (uic)))
2796 /* if shift operation make sure right side is not a literal */
2797 /* WIML: Why is this? */
2798 if (uic->op == RIGHT_OP &&
2799 (isOperandLiteral (IC_RIGHT (uic)) ||
2800 getSize (operandType (IC_RESULT (uic))) > 1))
2802 if (uic->op == LEFT_OP &&
2803 (isOperandLiteral (IC_RIGHT (uic)) ||
2804 getSize (operandType (IC_RESULT (uic))) > 1))
2807 /* make sure that the result of this icode is not on the
2808 stack, since acc is used to compute stack offset */
2810 if (IS_TRUE_SYMOP (IC_RESULT (uic)) &&
2811 OP_SYMBOL (IC_RESULT (uic))->onStack)
2814 if (isOperandOnStack(IC_RESULT(uic)))
2818 /* if the usage has only one operand then we can */
2819 if (IC_LEFT (uic) == NULL ||
2820 IC_RIGHT (uic) == NULL)
2823 /* if the other operand uses the accumulator then we cannot */
2824 if ( (IC_LEFT (uic)->key == IC_RESULT (ic)->key &&
2825 operandUsesAcc (IC_RIGHT (uic), IS_BIT (operandType (IC_LEFT (uic))))) ||
2826 (IC_RIGHT(uic)->key == IC_RESULT(ic)->key &&
2827 operandUsesAcc (IC_LEFT (uic), IS_BIT (operandType (IC_RIGHT (uic))))) )
2830 /* make sure this is on the left side if not commutative */
2831 /* except for '-', which has been written to be able to
2832 handle reversed operands */
2833 if (!(isCommutativeOp(ic->op) || ic->op == '-') &&
2834 IC_LEFT (uic)->key != IC_RESULT (ic)->key)
2838 // this is too dangerous and need further restrictions
2841 /* if one of them is a literal then we can */
2842 if ((IC_LEFT (uic) && IS_OP_LITERAL (IC_LEFT (uic))) ||
2843 (IC_RIGHT (uic) && IS_OP_LITERAL (IC_RIGHT (uic))))
2845 OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
2851 OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
2855 /*-----------------------------------------------------------------*/
2856 /* packForPush - heuristics to reduce iCode for pushing */
2857 /*-----------------------------------------------------------------*/
2859 packForPush (iCode * ic, eBBlock ** ebpp, int blockno)
2863 struct eBBlock * ebp=ebpp[blockno];
2865 if (ic->op != IPUSH || !IS_ITEMP (IC_LEFT (ic)))
2868 /* must have only definition & one usage */
2869 if (bitVectnBitsOn (OP_DEFS (IC_LEFT (ic))) != 1 ||
2870 bitVectnBitsOn (OP_USES (IC_LEFT (ic))) != 1)
2873 /* find the definition */
2874 if (!(dic = hTabItemWithKey (iCodehTab,
2875 bitVectFirstBit (OP_DEFS (IC_LEFT (ic))))))
2878 if (dic->op != '=' || POINTER_SET (dic))
2881 if (dic->seq < ebp->fSeq) { // Evelyn did this
2883 for (i=0; i<blockno; i++) {
2884 if (dic->seq >= ebpp[i]->fSeq && dic->seq <= ebpp[i]->lSeq) {
2889 wassert (i!=blockno); // no way to recover from here
2892 if (IS_SYMOP(IC_RIGHT(dic))) {
2893 /* make sure the right side does not have any definitions
2895 dbv = OP_DEFS(IC_RIGHT(dic));
2896 for (lic = ic; lic && lic != dic ; lic = lic->prev) {
2897 if (bitVectBitValue(dbv,lic->key))
2900 /* make sure they have the same type */
2901 if (IS_SPEC(operandType(IC_LEFT(ic))))
2903 sym_link *itype=operandType(IC_LEFT(ic));
2904 sym_link *ditype=operandType(IC_RIGHT(dic));
2906 if (SPEC_USIGN(itype)!=SPEC_USIGN(ditype) ||
2907 SPEC_LONG(itype)!=SPEC_LONG(ditype))
2910 /* extend the live range of replaced operand if needed */
2911 if (OP_SYMBOL(IC_RIGHT(dic))->liveTo < ic->seq) {
2912 OP_SYMBOL(IC_RIGHT(dic))->liveTo = ic->seq;
2914 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2917 /* we now we know that it has one & only one def & use
2918 and the that the definition is an assignment */
2919 ReplaceOpWithCheaperOp(&IC_LEFT (ic), IC_RIGHT (dic));
2920 remiCodeFromeBBlock (ebp, dic);
2921 hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2924 /*-----------------------------------------------------------------*/
2925 /* packRegisters - does some transformations to reduce register */
2927 /*-----------------------------------------------------------------*/
2929 packRegisters (eBBlock ** ebpp, int blockno)
2933 eBBlock *ebp=ebpp[blockno];
2939 /* look for assignments of the form */
2940 /* iTempNN = TRueSym (someoperation) SomeOperand */
2942 /* TrueSym := iTempNN:1 */
2943 for (ic = ebp->sch; ic; ic = ic->next)
2945 /* find assignment of the form TrueSym := iTempNN:1 */
2946 if (ic->op == '=' && !POINTER_SET (ic))
2947 change += packRegsForAssign (ic, ebp);
2954 for (ic = ebp->sch; ic; ic = ic->next)
2956 /* Fix for bug #979599: */
2959 /* Look for two subsequent iCodes with */
2961 /* _c = iTemp & op; */
2962 /* and replace them by */
2965 if ((ic->op == BITWISEAND || ic->op == '|' || ic->op == '^') &&
2967 ic->prev->op == '=' &&
2968 IS_ITEMP (IC_LEFT (ic)) &&
2969 IC_LEFT (ic) == IC_RESULT (ic->prev) &&
2970 isOperandEqual (IC_RESULT(ic), IC_RIGHT(ic->prev)))
2972 iCode* ic_prev = ic->prev;
2973 symbol* prev_result_sym = OP_SYMBOL (IC_RESULT (ic_prev));
2975 ReplaceOpWithCheaperOp (&IC_LEFT (ic), IC_RESULT (ic));
2976 if (IC_RESULT (ic_prev) != IC_RIGHT (ic))
2978 bitVectUnSetBit (OP_USES (IC_RESULT (ic_prev)), ic->key);
2979 if (/*IS_ITEMP (IC_RESULT (ic_prev)) && */
2980 prev_result_sym->liveTo == ic->seq)
2982 prev_result_sym->liveTo = ic_prev->seq;
2985 bitVectSetBit (OP_USES (IC_RESULT (ic)), ic->key);
2987 bitVectSetBit (ic->rlive, IC_RESULT (ic)->key);
2989 if (bitVectIsZero (OP_USES (IC_RESULT (ic_prev))))
2991 bitVectUnSetBit (ic->rlive, IC_RESULT (ic)->key);
2992 bitVectUnSetBit (OP_DEFS (IC_RESULT (ic_prev)), ic_prev->key);
2993 remiCodeFromeBBlock (ebp, ic_prev);
2994 hTabDeleteItem (&iCodehTab, ic_prev->key, ic_prev, DELETE_ITEM, NULL);
2998 /* if this is an itemp & result of an address of a true sym
2999 then mark this as rematerialisable */
3000 if (ic->op == ADDRESS_OF &&
3001 IS_ITEMP (IC_RESULT (ic)) &&
3002 IS_TRUE_SYMOP (IC_LEFT (ic)) &&
3003 bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
3004 !OP_SYMBOL (IC_LEFT (ic))->onStack)
3006 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
3007 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
3008 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
3011 /* if straight assignment then carry remat flag if
3012 this is the only definition */
3013 if (ic->op == '=' &&
3014 !POINTER_SET (ic) &&
3015 IS_SYMOP (IC_RIGHT (ic)) &&
3016 OP_SYMBOL (IC_RIGHT (ic))->remat &&
3017 !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode) &&
3018 bitVectnBitsOn (OP_SYMBOL (IC_RESULT (ic))->defs) <= 1)
3020 OP_SYMBOL (IC_RESULT (ic))->remat =
3021 OP_SYMBOL (IC_RIGHT (ic))->remat;
3022 OP_SYMBOL (IC_RESULT (ic))->rematiCode =
3023 OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
3026 /* if cast to a generic pointer & the pointer being
3027 cast is remat, then we can remat this cast as well */
3028 if (ic->op == CAST &&
3029 IS_SYMOP(IC_RIGHT(ic)) &&
3030 OP_SYMBOL(IC_RIGHT(ic))->remat &&
3031 bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1)
3033 sym_link *to_type = operandType(IC_LEFT(ic));
3034 sym_link *from_type = operandType(IC_RIGHT(ic));
3035 if (IS_GENPTR(to_type) && IS_PTR(from_type))
3037 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
3038 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
3039 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
3043 /* if this is a +/- operation with a rematerizable
3044 then mark this as rematerializable as well */
3045 if ((ic->op == '+' || ic->op == '-') &&
3046 (IS_SYMOP (IC_LEFT (ic)) &&
3047 IS_ITEMP (IC_RESULT (ic)) &&
3048 IS_OP_LITERAL (IC_RIGHT (ic))) &&
3049 OP_SYMBOL (IC_LEFT (ic))->remat &&
3050 (!IS_SYMOP (IC_RIGHT (ic)) || !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode)) &&
3051 bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1)
3053 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
3054 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
3055 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
3058 /* mark the pointer usages */
3059 if (POINTER_SET (ic) && IS_SYMOP (IC_RESULT (ic)))
3060 OP_SYMBOL (IC_RESULT (ic))->uptr = 1;
3062 if (POINTER_GET (ic) && IS_SYMOP (IC_LEFT (ic)))
3063 OP_SYMBOL (IC_LEFT (ic))->uptr = 1;
3067 /* if we are using a symbol on the stack
3068 then we should say mcs51_ptrRegReq */
3069 if (options.useXstack && ic->parmPush
3070 && (ic->op == IPUSH || ic->op == IPOP))
3072 if (ic->op == IFX && IS_SYMOP (IC_COND (ic)))
3073 mcs51_ptrRegReq += ((OP_SYMBOL (IC_COND (ic))->onStack ||
3074 OP_SYMBOL (IC_COND (ic))->iaccess ||
3075 SPEC_OCLS(OP_SYMBOL (IC_COND (ic))->etype) == idata) ? 1 : 0);
3076 else if (ic->op == JUMPTABLE && IS_SYMOP (IC_JTCOND (ic)))
3077 mcs51_ptrRegReq += ((OP_SYMBOL (IC_JTCOND (ic))->onStack ||
3078 OP_SYMBOL (IC_JTCOND (ic))->iaccess ||
3079 SPEC_OCLS(OP_SYMBOL (IC_JTCOND (ic))->etype) == idata) ? 1 : 0);
3082 if (IS_SYMOP (IC_LEFT (ic)))
3083 mcs51_ptrRegReq += ((OP_SYMBOL (IC_LEFT (ic))->onStack ||
3084 OP_SYMBOL (IC_LEFT (ic))->iaccess ||
3085 SPEC_OCLS(OP_SYMBOL (IC_LEFT (ic))->etype) == idata) ? 1 : 0);
3086 if (IS_SYMOP (IC_RIGHT (ic)))
3087 mcs51_ptrRegReq += ((OP_SYMBOL (IC_RIGHT (ic))->onStack ||
3088 OP_SYMBOL (IC_RIGHT (ic))->iaccess ||
3089 SPEC_OCLS(OP_SYMBOL (IC_RIGHT (ic))->etype) == idata) ? 1 : 0);
3090 if (IS_SYMOP (IC_RESULT (ic)))
3091 mcs51_ptrRegReq += ((OP_SYMBOL (IC_RESULT (ic))->onStack ||
3092 OP_SYMBOL (IC_RESULT (ic))->iaccess ||
3093 SPEC_OCLS(OP_SYMBOL (IC_RESULT (ic))->etype) == idata) ? 1 : 0);
3094 if (POINTER_GET (ic) && IS_SYMOP (IC_LEFT (ic))
3095 && getSize (OP_SYMBOL (IC_LEFT (ic))->type) <= (unsigned int) PTRSIZE)
3097 if (POINTER_SET (ic) && IS_SYMOP (IC_RESULT (ic))
3098 && getSize (OP_SYMBOL (IC_RESULT (ic))->type) <= (unsigned int) PTRSIZE)
3103 /* if the condition of an if instruction
3104 is defined in the previous instruction and
3105 this is the only usage then
3106 mark the itemp as a conditional */
3107 if ((IS_CONDITIONAL (ic) ||
3108 (IS_BITWISE_OP(ic) && isBitwiseOptimizable (ic))) &&
3109 ic->next && ic->next->op == IFX &&
3110 bitVectnBitsOn (OP_USES(IC_RESULT(ic)))==1 &&
3111 isOperandEqual (IC_RESULT (ic), IC_COND (ic->next)) &&
3112 OP_SYMBOL (IC_RESULT (ic))->liveTo <= ic->next->seq)
3114 OP_SYMBOL (IC_RESULT (ic))->regType = REG_CND;
3118 /* if the condition of an if instruction
3119 is defined in the previous GET_POINTER instruction and
3120 this is the only usage then
3121 mark the itemp as accumulator use */
3122 if ((POINTER_GET (ic) && getSize (operandType (IC_RESULT (ic))) <=1) &&
3123 ic->next && ic->next->op == IFX &&
3124 bitVectnBitsOn (OP_USES(IC_RESULT(ic)))==1 &&
3125 isOperandEqual (IC_RESULT (ic), IC_COND (ic->next)) &&
3126 OP_SYMBOL (IC_RESULT (ic))->liveTo <= ic->next->seq)
3128 OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
3132 /* reduce for support function calls */
3133 if (ic->supportRtn || ic->op == '+' || ic->op == '-')
3134 packRegsForSupport (ic, ebp);
3136 /* some cases the redundant moves can
3137 can be eliminated for return statements */
3138 if ((ic->op == RETURN || (ic->op == SEND && ic->argreg == 1)) &&
3139 !isOperandInFarSpace (IC_LEFT (ic)) &&
3140 options.model == MODEL_SMALL) {
3141 packRegsForOneuse (ic, IC_LEFT (ic), ebp);
3144 /* if pointer set & left has a size more than
3145 one and right is not in far space */
3146 if (POINTER_SET (ic) &&
3147 IS_SYMOP (IC_RESULT (ic)) &&
3148 !isOperandInFarSpace (IC_RIGHT (ic)) &&
3149 !OP_SYMBOL (IC_RESULT (ic))->remat &&
3150 !IS_OP_RUONLY (IC_RIGHT (ic)) &&
3151 getSize (aggrToPtr (operandType (IC_RESULT (ic)), FALSE)) > 1)
3152 packRegsForOneuse (ic, IC_RESULT (ic), ebp);
3154 /* if pointer get */
3155 if (POINTER_GET (ic) &&
3156 IS_SYMOP (IC_LEFT (ic)) &&
3157 !isOperandInFarSpace (IC_RESULT (ic)) &&
3158 !OP_SYMBOL (IC_LEFT (ic))->remat &&
3159 !IS_OP_RUONLY (IC_RESULT (ic)) &&
3160 getSize (aggrToPtr (operandType (IC_LEFT (ic)), FALSE)) > 1)
3161 packRegsForOneuse (ic, IC_LEFT (ic), ebp);
3163 /* if this is a cast for intergral promotion then
3164 check if it's the only use of the definition of the
3165 operand being casted/ if yes then replace
3166 the result of that arithmetic operation with
3167 this result and get rid of the cast */
3170 sym_link *fromType = operandType (IC_RIGHT (ic));
3171 sym_link *toType = operandType (IC_LEFT (ic));
3173 if (IS_INTEGRAL (fromType) && IS_INTEGRAL (toType) &&
3174 getSize (fromType) != getSize (toType) &&
3175 SPEC_USIGN (fromType) == SPEC_USIGN (toType))
3178 iCode *dic = packRegsForOneuse (ic, IC_RIGHT (ic), ebp);
3181 if (IS_ARITHMETIC_OP (dic))
3183 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
3184 ReplaceOpWithCheaperOp(&IC_RESULT (dic), IC_RESULT (ic));
3185 remiCodeFromeBBlock (ebp, ic);
3186 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
3187 hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
3188 OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
3192 OP_SYMBOL (IC_RIGHT (ic))->ruonly = 0;
3197 /* if the type from and type to are the same
3198 then if this is the only use then packit */
3199 if (compareType (operandType (IC_RIGHT (ic)),
3200 operandType (IC_LEFT (ic))) == 1)
3202 iCode *dic = packRegsForOneuse (ic, IC_RIGHT (ic), ebp);
3205 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
3206 ReplaceOpWithCheaperOp(&IC_RESULT (dic), IC_RESULT (ic));
3207 remiCodeFromeBBlock (ebp, ic);
3208 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
3209 hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
3210 OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
3218 iTempNN := (some variable in farspace) V1
3223 if (ic->op == IPUSH)
3225 packForPush (ic, ebpp, blockno);
3229 /* pack registers for accumulator use, when the
3230 result of an arithmetic or bit wise operation
3231 has only one use, that use is immediately following
3232 the definition and the using iCode has only one
3233 operand or has two operands but one is literal &
3234 the result of that operation is not on stack then
3235 we can leave the result of this operation in acc:b
3237 if ((IS_ARITHMETIC_OP (ic)
3238 || IS_CONDITIONAL(ic)
3239 || IS_BITWISE_OP (ic)
3240 || ic->op == LEFT_OP || ic->op == RIGHT_OP || ic->op == CALL
3241 || (ic->op == ADDRESS_OF && isOperandOnStack (IC_LEFT (ic)))
3243 IS_ITEMP (IC_RESULT (ic)) &&
3244 getSize (operandType (IC_RESULT (ic))) <= 2)
3246 packRegsForAccUse (ic);
3250 /*-----------------------------------------------------------------*/
3251 /* assignRegisters - assigns registers to each live range as need */
3252 /*-----------------------------------------------------------------*/
3254 mcs51_assignRegisters (ebbIndex * ebbi)
3256 eBBlock ** ebbs = ebbi->bbOrder;
3257 int count = ebbi->count;
3261 setToNull ((void *) &_G.funcrUsed);
3262 setToNull ((void *) &_G.regAssigned);
3263 setToNull ((void *) &_G.totRegAssigned);
3264 mcs51_ptrRegReq = _G.stackExtend = _G.dataExtend = 0;
3265 if ((currFunc && IFFUNC_ISREENT (currFunc->type)) || options.stackAuto)
3273 _G.allBitregs = findAllBitregs ();
3276 /* change assignments this will remove some
3277 live ranges reducing some register pressure */
3279 for (i = 0; i < count; i++)
3280 packRegisters (ebbs, i);
3282 /* liveranges probably changed by register packing
3283 so we compute them again */
3284 recomputeLiveRanges (ebbs, count);
3286 if (options.dump_pack)
3287 dumpEbbsToFileExt (DUMP_PACK, ebbi);
3289 /* first determine for each live range the number of
3290 registers & the type of registers required for each */
3293 /* and serially allocate registers */
3294 serialRegAssign (ebbs, count);
3297 //setToNull ((void *) &_G.regAssigned);
3298 //setToNull ((void *) &_G.totRegAssigned);
3301 /* if stack was extended then tell the user */
3304 /* werror(W_TOOMANY_SPILS,"stack", */
3305 /* _G.stackExtend,currFunc->name,""); */
3311 /* werror(W_TOOMANY_SPILS,"data space", */
3312 /* _G.dataExtend,currFunc->name,""); */
3316 /* after that create the register mask
3317 for each of the instruction */
3318 createRegMask (ebbs, count);
3320 /* redo that offsets for stacked automatic variables */
3322 redoStackOffsets ();
3325 /* make sure r0 & r1 are flagged as used if they might be used */
3327 if (currFunc && mcs51_ptrRegReq)
3329 currFunc->regsUsed = bitVectSetBit (currFunc->regsUsed, R0_IDX);
3330 currFunc->regsUsed = bitVectSetBit (currFunc->regsUsed, R1_IDX);
3333 if (options.dump_rassgn)
3335 dumpEbbsToFileExt (DUMP_RASSGN, ebbi);
3336 dumpLiveRanges (DUMP_LRANGE, liveRanges);
3339 /* do the overlaysegment stuff SDCCmem.c */
3340 doOverlays (ebbs, count);
3342 /* now get back the chain */
3343 ic = iCodeLabelOptimize (iCodeFromeBBlock (ebbs, count));
3347 /* free up any _G.stackSpil locations allocated */
3348 applyToSet (_G.stackSpil, deallocStackSpil);
3350 setToNull ((void *) &_G.stackSpil);
3351 setToNull ((void *) &_G.spiltSet);
3352 /* mark all registers as free */