1 /*------------------------------------------------------------------------
3 SDCCralloc.c - source file for register allocation. 68HC08 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 genhc08Code (iCode *);
48 bitVect *totRegAssigned; /* final set of LRs that got into registers */
51 bitVect *funcrUsed; /* registers used in a function */
57 /* Shared with gen.c */
58 int hc08_ptrRegReq; /* one byte pointer register required */
64 {REG_GPR, A_IDX, "a", 1, NULL, 0, 1},
65 {REG_GPR, X_IDX, "x", 2, NULL, 0, 1},
66 {REG_GPR, H_IDX, "h", 4, NULL, 0, 1},
67 {REG_PTR, HX_IDX, "hx", 6, NULL, 0, 1},
68 {REG_GPR, XA_IDX, "xa", 3, NULL, 0, 1},
70 {REG_CND, CND_IDX, "C", 0, NULL, 0, 1},
71 {0, SP_IDX, "sp", 0, NULL, 0, 1},
82 static void spillThis (symbol *);
83 static void freeAllRegs ();
85 /*-----------------------------------------------------------------*/
86 /* allocReg - allocates register of given type */
87 /*-----------------------------------------------------------------*/
93 if ((type==REG_PTR) && (regshc08[HX_IDX].isFree))
95 regshc08[HX_IDX].isFree = 0;
98 bitVectSetBit (currFunc->regsUsed, HX_IDX);
99 return ®shc08[HX_IDX];
104 /*-----------------------------------------------------------------*/
105 /* hc08_regWithIdx - returns pointer to register wit index number */
106 /*-----------------------------------------------------------------*/
108 hc08_regWithIdx (int idx)
112 for (i = 0; i < hc08_nRegs; i++)
113 if (regshc08[i].rIdx == idx)
116 werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
117 "regWithIdx not found");
121 /*-----------------------------------------------------------------*/
122 /* hc08_freeReg - frees a register */
123 /*-----------------------------------------------------------------*/
125 hc08_freeReg (regs * reg)
129 werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
130 "hc08_freeReg - Freeing NULL register");
139 if (hc08_reg_x->isFree)
140 hc08_reg_xa->isFree = 1;
143 if (hc08_reg_a->isFree)
144 hc08_reg_xa->isFree = 1;
145 if (hc08_reg_h->isFree)
146 hc08_reg_hx->isFree = 1;
149 if (hc08_reg_x->isFree)
150 hc08_reg_hx->isFree = 1;
153 hc08_reg_h->isFree = 1;
154 hc08_reg_x->isFree = 1;
155 if (hc08_reg_a->isFree)
156 hc08_reg_xa->isFree = 1;
159 hc08_reg_x->isFree = 1;
160 hc08_reg_a->isFree = 1;
161 if (hc08_reg_h->isFree)
162 hc08_reg_hx->isFree = 1;
170 /*-----------------------------------------------------------------*/
171 /* nFreeRegs - returns number of free registers */
172 /*-----------------------------------------------------------------*/
181 for (i = 0; i < hc08_nRegs; i++)
182 if (regshc08[i].isFree && regshc08[i].type == type)
187 /*-----------------------------------------------------------------*/
188 /* nfreeRegsType - free registers with type */
189 /*-----------------------------------------------------------------*/
191 nfreeRegsType (int type)
196 if ((nfr = nFreeRegs (type)) == 0)
197 return nFreeRegs (REG_GPR);
200 return nFreeRegs (type);
203 /*-----------------------------------------------------------------*/
204 /* hc08_useReg - marks a register as used */
205 /*-----------------------------------------------------------------*/
207 hc08_useReg (regs * reg)
214 hc08_reg_xa->aop = NULL;
215 hc08_reg_xa->isFree = 0;
218 hc08_reg_xa->aop = NULL;
219 hc08_reg_xa->isFree = 0;
220 hc08_reg_hx->aop = NULL;
221 hc08_reg_hx->isFree = 0;
224 hc08_reg_hx->aop = NULL;
225 hc08_reg_hx->isFree = 0;
228 hc08_reg_h->aop = NULL;
229 hc08_reg_h->isFree = 0;
230 hc08_reg_x->aop = NULL;
231 hc08_reg_x->isFree = 0;
234 hc08_reg_x->aop = NULL;
235 hc08_reg_x->isFree = 0;
236 hc08_reg_a->aop = NULL;
237 hc08_reg_a->isFree = 0;
245 /*-----------------------------------------------------------------*/
246 /* hc08_dirtyReg - marks a register as dirty */
247 /*-----------------------------------------------------------------*/
249 hc08_dirtyReg (regs * reg, bool freereg)
256 hc08_reg_xa->aop = NULL;
259 hc08_reg_xa->aop = NULL;
260 hc08_reg_hx->aop = NULL;
263 hc08_reg_hx->aop = NULL;
266 hc08_reg_h->aop = NULL;
267 hc08_reg_x->aop = NULL;
270 hc08_reg_x->aop = NULL;
271 hc08_reg_a->aop = NULL;
280 /*-----------------------------------------------------------------*/
281 /* computeSpillable - given a point find the spillable live ranges */
282 /*-----------------------------------------------------------------*/
284 computeSpillable (iCode * ic)
288 /* spillable live ranges are those that are live at this
289 point . the following categories need to be subtracted
291 a) - those that are already spilt
292 b) - if being used by this one
293 c) - defined by this one */
295 spillable = bitVectCopy (ic->rlive);
297 bitVectCplAnd (spillable, _G.spiltSet); /* those already spilt */
299 bitVectCplAnd (spillable, ic->uses); /* used in this one */
300 bitVectUnSetBit (spillable, ic->defKey);
301 spillable = bitVectIntersect (spillable, _G.regAssigned);
306 /*-----------------------------------------------------------------*/
307 /* noSpilLoc - return true if a variable has no spil location */
308 /*-----------------------------------------------------------------*/
310 noSpilLoc (symbol * sym, eBBlock * ebp, iCode * ic)
312 return (sym->usl.spillLoc ? 0 : 1);
315 /*-----------------------------------------------------------------*/
316 /* hasSpilLoc - will return 1 if the symbol has spil location */
317 /*-----------------------------------------------------------------*/
319 hasSpilLoc (symbol * sym, eBBlock * ebp, iCode * ic)
321 return (sym->usl.spillLoc ? 1 : 0);
324 /*-----------------------------------------------------------------*/
325 /* directSpilLoc - will return 1 if the splilocation is in direct */
326 /*-----------------------------------------------------------------*/
328 directSpilLoc (symbol * sym, eBBlock * ebp, iCode * ic)
330 if (sym->usl.spillLoc &&
331 (IN_DIRSPACE (SPEC_OCLS (sym->usl.spillLoc->etype))))
337 /*-----------------------------------------------------------------*/
338 /* hasSpilLocnoUptr - will return 1 if the symbol has spil location */
339 /* but is not used as a pointer */
340 /*-----------------------------------------------------------------*/
342 hasSpilLocnoUptr (symbol * sym, eBBlock * ebp, iCode * ic)
344 return ((sym->usl.spillLoc && !sym->uptr) ? 1 : 0);
347 /*-----------------------------------------------------------------*/
348 /* rematable - will return 1 if the remat flag is set */
349 /*-----------------------------------------------------------------*/
351 rematable (symbol * sym, eBBlock * ebp, iCode * ic)
356 /*-----------------------------------------------------------------*/
357 /* notUsedInRemaining - not used or defined in remain of the block */
358 /*-----------------------------------------------------------------*/
360 notUsedInRemaining (symbol * sym, eBBlock * ebp, iCode * ic)
362 return ((usedInRemaining (operandFromSymbol (sym), ic) ? 0 : 1) &&
363 allDefsOutOfRange (sym->defs, ebp->fSeq, ebp->lSeq));
366 /*-----------------------------------------------------------------*/
367 /* allLRs - return true for all */
368 /*-----------------------------------------------------------------*/
370 allLRs (symbol * sym, eBBlock * ebp, iCode * ic)
375 /*-----------------------------------------------------------------*/
376 /* liveRangesWith - applies function to a given set of live range */
377 /*-----------------------------------------------------------------*/
379 liveRangesWith (bitVect * lrs, int (func) (symbol *, eBBlock *, iCode *),
380 eBBlock * ebp, iCode * ic)
385 if (!lrs || !lrs->size)
388 for (i = 1; i < lrs->size; i++)
391 if (!bitVectBitValue (lrs, i))
394 /* if we don't find it in the live range
395 hash table we are in serious trouble */
396 if (!(sym = hTabItemWithKey (liveRanges, i)))
398 werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
399 "liveRangesWith could not find liveRange");
403 if (func (sym, ebp, ic) && bitVectBitValue (_G.regAssigned, sym->key))
404 addSetHead (&rset, sym);
411 /*-----------------------------------------------------------------*/
412 /* leastUsedLR - given a set determines which is the least used */
413 /*-----------------------------------------------------------------*/
415 leastUsedLR (set * sset)
417 symbol *sym = NULL, *lsym = NULL;
419 sym = lsym = setFirstItem (sset);
424 for (; lsym; lsym = setNextItem (sset))
427 /* if usage is the same then prefer
428 the spill the smaller of the two */
429 if (lsym->used == sym->used)
430 if (getSize (lsym->type) < getSize (sym->type))
434 if (lsym->used < sym->used)
439 setToNull ((void *) &sset);
444 /*-----------------------------------------------------------------*/
445 /* noOverLap - will iterate through the list looking for over lap */
446 /*-----------------------------------------------------------------*/
448 noOverLap (set * itmpStack, symbol * fsym)
453 for (sym = setFirstItem (itmpStack); sym;
454 sym = setNextItem (itmpStack))
456 if (bitVectBitValue(sym->clashes,fsym->key)) return 0;
462 /*-----------------------------------------------------------------*/
463 /* isFree - will return 1 if the a free spil location is found */
464 /*-----------------------------------------------------------------*/
469 V_ARG (symbol **, sloc);
470 V_ARG (symbol *, fsym);
472 /* if already found */
476 /* if it is free && and the itmp assigned to
477 this does not have any overlapping live ranges
478 with the one currently being assigned and
479 the size can be accomodated */
481 noOverLap (sym->usl.itmpStack, fsym) &&
482 getSize (sym->type) >= getSize (fsym->type))
491 /*-----------------------------------------------------------------*/
492 /* spillLRWithPtrReg :- will spil those live ranges which use PTR */
493 /*-----------------------------------------------------------------*/
495 spillLRWithPtrReg (symbol * forSym)
501 if (!_G.regAssigned ||
502 bitVectIsZero (_G.regAssigned))
505 hx = hc08_regWithIdx (HX_IDX);
507 /* for all live ranges */
508 for (lrsym = hTabFirstItem (liveRanges, &k); lrsym;
509 lrsym = hTabNextItem (liveRanges, &k))
513 /* if no registers assigned to it or spilt */
514 /* if it does not overlap with this then
515 not need to spill it */
517 if (lrsym->isspilt || !lrsym->nRegs ||
518 (lrsym->liveTo < forSym->liveFrom))
521 /* go thru the registers : if it is either
522 r0 or r1 then spil it */
523 for (j = 0; j < lrsym->nRegs; j++)
524 if (lrsym->regs[j] == hx)
533 /*-----------------------------------------------------------------*/
534 /* createStackSpil - create a location on the stack to spil */
535 /*-----------------------------------------------------------------*/
537 createStackSpil (symbol * sym)
540 int useXstack, model;
544 /* first go try and find a free one that is already
545 existing on the stack */
546 if (applyToSet (_G.stackSpil, isFree, &sloc, sym))
548 /* found a free one : just update & return */
549 sym->usl.spillLoc = sloc;
552 addSetHead (&sloc->usl.itmpStack, sym);
556 /* could not then have to create one , this is the hard part
557 we need to allocate this on the stack : this is really a
558 hack!! but cannot think of anything better at this time */
560 if (sprintf (slocBuffer, "sloc%d", _G.slocNum++) >= sizeof (slocBuffer))
562 fprintf (stderr, "***Internal error: slocBuffer overflowed: %s:%d\n",
567 sloc = newiTemp (slocBuffer);
569 /* set the type to the spilling symbol */
570 sloc->type = copyLinkChain (sym->type);
571 sloc->etype = getSpec (sloc->type);
572 SPEC_SCLS (sloc->etype) = S_DATA;
573 SPEC_EXTR (sloc->etype) = 0;
574 SPEC_STAT (sloc->etype) = 0;
575 SPEC_VOLATILE(sloc->etype) = 0;
576 SPEC_ABSA(sloc->etype) = 0;
578 /* we don't allow it to be allocated`
579 onto the external stack since : so we
580 temporarily turn it off ; we also
581 turn off memory model to prevent
582 the spil from going to the external storage
585 useXstack = options.useXstack;
586 model = options.model;
587 /* noOverlay = options.noOverlay; */
588 /* options.noOverlay = 1; */
589 options.model = options.useXstack = 0;
593 options.useXstack = useXstack;
594 options.model = model;
595 /* options.noOverlay = noOverlay; */
596 sloc->isref = 1; /* to prevent compiler warning */
598 /* if it is on the stack then update the stack */
599 if (IN_STACK (sloc->etype))
601 currFunc->stack += getSize (sloc->type);
602 _G.stackExtend += getSize (sloc->type);
605 _G.dataExtend += getSize (sloc->type);
607 /* add it to the _G.stackSpil set */
608 addSetHead (&_G.stackSpil, sloc);
609 sym->usl.spillLoc = sloc;
612 /* add it to the set of itempStack set
613 of the spill location */
614 addSetHead (&sloc->usl.itmpStack, sym);
618 /*-----------------------------------------------------------------*/
619 /* isSpiltOnStack - returns true if the spil location is on stack */
620 /*-----------------------------------------------------------------*/
622 isSpiltOnStack (symbol * sym)
632 /* if (sym->_G.stackSpil) */
635 if (!sym->usl.spillLoc)
638 etype = getSpec (sym->usl.spillLoc->type);
639 if (IN_STACK (etype))
645 /*-----------------------------------------------------------------*/
646 /* spillThis - spils a specific operand */
647 /*-----------------------------------------------------------------*/
649 spillThis (symbol * sym)
652 /* if this is rematerializable or has a spillLocation
653 we are okay, else we need to create a spillLocation
655 if (!(sym->remat || sym->usl.spillLoc))
656 createStackSpil (sym);
658 /* mark it as spilt & put it in the spilt set */
659 sym->isspilt = sym->spillA = 1;
660 _G.spiltSet = bitVectSetBit (_G.spiltSet, sym->key);
662 bitVectUnSetBit (_G.regAssigned, sym->key);
663 bitVectUnSetBit (_G.totRegAssigned, sym->key);
665 for (i = 0; i < sym->nRegs; i++)
669 hc08_freeReg (sym->regs[i]);
673 /* if spilt on stack then free up r0 & r1
674 if they could have been assigned to some
676 // if (!hc08_ptrRegReq && isSpiltOnStack (sym))
679 // spillLRWithPtrReg (sym);
682 if (sym->usl.spillLoc && !sym->remat)
683 sym->usl.spillLoc->allocreq++;
687 /*-----------------------------------------------------------------*/
688 /* selectSpil - select a iTemp to spil : rather a simple procedure */
689 /*-----------------------------------------------------------------*/
691 selectSpil (iCode * ic, eBBlock * ebp, symbol * forSym)
693 bitVect *lrcs = NULL;
697 /* get the spillable live ranges */
698 lrcs = computeSpillable (ic);
700 /* get all live ranges that are rematerizable */
701 if ((selectS = liveRangesWith (lrcs, rematable, ebp, ic)))
704 /* return the least used of these */
705 return leastUsedLR (selectS);
708 /* get live ranges with spillLocations in direct space */
709 if ((selectS = liveRangesWith (lrcs, directSpilLoc, ebp, ic)))
711 sym = leastUsedLR (selectS);
712 strcpy (sym->rname, (sym->usl.spillLoc->rname[0] ?
713 sym->usl.spillLoc->rname :
714 sym->usl.spillLoc->name));
716 /* mark it as allocation required */
717 sym->usl.spillLoc->allocreq++;
721 /* if the symbol is local to the block then */
722 if (forSym->liveTo < ebp->lSeq)
725 /* check if there are any live ranges allocated
726 to registers that are not used in this block */
727 if (!_G.blockSpil && (selectS = liveRangesWith (lrcs, notUsedInBlock, ebp, ic)))
729 sym = leastUsedLR (selectS);
730 /* if this is not rematerializable */
739 /* check if there are any live ranges that not
740 used in the remainder of the block */
742 !isiCodeInFunctionCall (ic) &&
743 (selectS = liveRangesWith (lrcs, notUsedInRemaining, ebp, ic)))
745 sym = leastUsedLR (selectS);
758 /* find live ranges with spillocation && not used as pointers */
759 if ((selectS = liveRangesWith (lrcs, hasSpilLocnoUptr, ebp, ic)))
762 sym = leastUsedLR (selectS);
763 /* mark this as allocation required */
764 sym->usl.spillLoc->allocreq++;
768 /* find live ranges with spillocation */
769 if ((selectS = liveRangesWith (lrcs, hasSpilLoc, ebp, ic)))
772 sym = leastUsedLR (selectS);
773 sym->usl.spillLoc->allocreq++;
777 /* couldn't find then we need to create a spil
778 location on the stack , for which one? the least
780 if ((selectS = liveRangesWith (lrcs, noSpilLoc, ebp, ic)))
783 /* return a created spil location */
784 sym = createStackSpil (leastUsedLR (selectS));
785 sym->usl.spillLoc->allocreq++;
789 /* this is an extreme situation we will spill
790 this one : happens very rarely but it does happen */
796 /*-----------------------------------------------------------------*/
797 /* spilSomething - spil some variable & mark registers as free */
798 /*-----------------------------------------------------------------*/
800 spilSomething (iCode * ic, eBBlock * ebp, symbol * forSym)
805 /* get something we can spil */
806 ssym = selectSpil (ic, ebp, forSym);
808 /* mark it as spilt */
809 ssym->isspilt = ssym->spillA = 1;
810 _G.spiltSet = bitVectSetBit (_G.spiltSet, ssym->key);
812 /* mark it as not register assigned &
813 take it away from the set */
814 bitVectUnSetBit (_G.regAssigned, ssym->key);
815 bitVectUnSetBit (_G.totRegAssigned, ssym->key);
817 /* mark the registers as free */
818 for (i = 0; i < ssym->nRegs; i++)
820 hc08_freeReg (ssym->regs[i]);
822 /* if spilt on stack then free up hx
823 if it could have been assigned to as gprs */
824 if (!hc08_ptrRegReq && isSpiltOnStack (ssym))
827 spillLRWithPtrReg (ssym);
830 /* if this was a block level spil then insert push & pop
831 at the start & end of block respectively */
834 iCode *nic = newiCode (IPUSH, operandFromSymbol (ssym), NULL);
835 /* add push to the start of the block */
836 addiCodeToeBBlock (ebp, nic, (ebp->sch->op == LABEL ?
837 ebp->sch->next : ebp->sch));
838 nic = newiCode (IPOP, operandFromSymbol (ssym), NULL);
839 /* add pop to the end of the block */
840 addiCodeToeBBlock (ebp, nic, NULL);
843 /* if spilt because not used in the remainder of the
844 block then add a push before this instruction and
845 a pop at the end of the block */
846 if (ssym->remainSpil)
849 iCode *nic = newiCode (IPUSH, operandFromSymbol (ssym), NULL);
850 /* add push just before this instruction */
851 addiCodeToeBBlock (ebp, nic, ic);
853 nic = newiCode (IPOP, operandFromSymbol (ssym), NULL);
854 /* add pop to the end of the block */
855 addiCodeToeBBlock (ebp, nic, NULL);
864 /*-----------------------------------------------------------------*/
865 /* getRegPtr - will try for PTR if not a GPR type if not spil */
866 /*-----------------------------------------------------------------*/
868 getRegPtr (iCode * ic, eBBlock * ebp, symbol * sym)
873 /* try for a ptr type */
874 if ((reg = allocReg (REG_PTR)))
877 /* try for gpr type */
878 if ((reg = allocReg (REG_GPR)))
881 /* we have to spil */
882 if (!spilSomething (ic, ebp, sym))
885 /* this looks like an infinite loop but
886 in really selectSpil will abort */
890 /*-----------------------------------------------------------------*/
891 /* getRegGpr - will try for GPR if not spil */
892 /*-----------------------------------------------------------------*/
894 getRegGpr (iCode * ic, eBBlock * ebp, symbol * sym)
899 /* try for gpr type */
900 if ((reg = allocReg (REG_GPR)))
904 if ((reg = allocReg (REG_PTR)))
907 /* we have to spil */
908 if (!spilSomething (ic, ebp, sym))
911 /* this looks like an infinite loop but
912 in really selectSpil will abort */
916 /*-----------------------------------------------------------------*/
917 /* getRegPtrNoSpil - get it cannot split */
918 /*-----------------------------------------------------------------*/
919 static regs *getRegPtrNoSpil()
923 /* try for a ptr type */
924 if ((reg = allocReg (REG_PTR)))
927 /* try for gpr type */
928 if ((reg = allocReg (REG_GPR)))
933 /* just to make the compiler happy */
937 /*-----------------------------------------------------------------*/
938 /* getRegGprNoSpil - get it cannot split */
939 /*-----------------------------------------------------------------*/
940 static regs *getRegGprNoSpil()
944 if ((reg = allocReg (REG_GPR)))
948 if ((reg = allocReg (REG_PTR)))
953 /* just to make the compiler happy */
957 /*-----------------------------------------------------------------*/
958 /* symHasReg - symbol has a given register */
959 /*-----------------------------------------------------------------*/
961 symHasReg (symbol * sym, regs * reg)
965 for (i = 0; i < sym->nRegs; i++)
966 if (sym->regs[i] == reg)
972 /*-----------------------------------------------------------------*/
973 /* deassignLRs - check the live to and if they have registers & are */
974 /* not spilt then free up the registers */
975 /*-----------------------------------------------------------------*/
977 deassignLRs (iCode * ic, eBBlock * ebp)
983 for (sym = hTabFirstItem (liveRanges, &k); sym;
984 sym = hTabNextItem (liveRanges, &k))
988 /* if it does not end here */
989 if (sym->liveTo > ic->seq)
992 /* if it was spilt on stack then we can
993 mark the stack spil location as free */
998 sym->usl.spillLoc->isFree = 1;
1004 if (!bitVectBitValue (_G.regAssigned, sym->key))
1007 /* special case check if this is an IFX &
1008 the privious one was a pop and the
1009 previous one was not spilt then keep track
1011 if (ic->op == IFX && ic->prev &&
1012 ic->prev->op == IPOP &&
1013 !ic->prev->parmPush &&
1014 !OP_SYMBOL (IC_LEFT (ic->prev))->isspilt)
1015 psym = OP_SYMBOL (IC_LEFT (ic->prev));
1021 bitVectUnSetBit (_G.regAssigned, sym->key);
1023 /* if the result of this one needs registers
1024 and does not have it then assign it right
1026 if (IC_RESULT (ic) &&
1027 !(SKIP_IC2 (ic) || /* not a special icode */
1028 ic->op == JUMPTABLE ||
1033 POINTER_SET (ic)) &&
1034 (result = OP_SYMBOL (IC_RESULT (ic))) && /* has a result */
1035 result->liveTo > ic->seq && /* and will live beyond this */
1036 result->liveTo <= ebp->lSeq && /* does not go beyond this block */
1037 result->liveFrom == ic->seq && /* does not start before here */
1038 result->regType == sym->regType && /* same register types */
1039 result->nRegs && /* which needs registers */
1040 !result->isspilt && /* and does not already have them */
1042 !bitVectBitValue (_G.regAssigned, result->key) &&
1043 /* the number of free regs + number of regs in this LR
1044 can accomodate the what result Needs */
1045 ((nfreeRegsType (result->regType) +
1046 sym->nRegs) >= result->nRegs)
1050 for (i = 0; i < result->nRegs; i++)
1052 result->regs[i] = sym->regs[i];
1054 result->regs[i] = getRegGpr (ic, ebp, result);
1056 _G.regAssigned = bitVectSetBit (_G.regAssigned, result->key);
1057 _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, result->key);
1061 /* free the remaining */
1062 for (; i < sym->nRegs; i++)
1066 if (!symHasReg (psym, sym->regs[i]))
1067 hc08_freeReg (sym->regs[i]);
1070 hc08_freeReg (sym->regs[i]);
1077 /*-----------------------------------------------------------------*/
1078 /* reassignLR - reassign this to registers */
1079 /*-----------------------------------------------------------------*/
1081 reassignLR (operand * op)
1083 symbol *sym = OP_SYMBOL (op);
1086 /* not spilt any more */
1087 sym->isspilt = sym->spillA = sym->blockSpil = sym->remainSpil = 0;
1088 bitVectUnSetBit (_G.spiltSet, sym->key);
1090 _G.regAssigned = bitVectSetBit (_G.regAssigned, sym->key);
1091 _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, sym->key);
1095 for (i = 0; i < sym->nRegs; i++)
1096 sym->regs[i]->isFree = 0;
1099 /*-----------------------------------------------------------------*/
1100 /* willCauseSpill - determines if allocating will cause a spill */
1101 /*-----------------------------------------------------------------*/
1103 willCauseSpill (int nr, int rt)
1105 /* first check if there are any avlb registers
1106 of te type required */
1109 /* special case for pointer type
1110 if pointer type not avlb then
1111 check for type gpr */
1112 if (nFreeRegs (rt) >= nr)
1114 if (nFreeRegs (REG_GPR) >= nr)
1121 if (nFreeRegs (rt) >= nr)
1126 if (nFreeRegs (REG_PTR) +
1127 nFreeRegs (REG_GPR) >= nr)
1132 /* it will cause a spil */
1136 /*-----------------------------------------------------------------*/
1137 /* positionRegs - the allocator can allocate same registers to res- */
1138 /* ult and operand, if this happens make sure they are in the same */
1139 /* position as the operand otherwise chaos results */
1140 /*-----------------------------------------------------------------*/
1142 positionRegs (symbol * result, symbol * opsym)
1144 int count = min (result->nRegs, opsym->nRegs);
1145 int i, j = 0, shared = 0;
1148 /* if the result has been spilt then cannot share */
1153 /* first make sure that they actually share */
1154 for (i = 0; i < count; i++)
1156 for (j = 0; j < count; j++)
1158 if (result->regs[i] == opsym->regs[j] && i != j)
1168 regs *tmp = result->regs[i];
1169 result->regs[i] = result->regs[j];
1170 result->regs[j] = tmp;
1177 /*------------------------------------------------------------------*/
1178 /* verifyRegsAssigned - make sure an iTemp is properly initialized; */
1179 /* it should either have registers or have beed spilled. Otherwise, */
1180 /* there was an uninitialized variable, so just spill this to get */
1181 /* the operand in a valid state. */
1182 /*------------------------------------------------------------------*/
1184 verifyRegsAssigned (operand *op, iCode * ic)
1189 if (!IS_ITEMP (op)) return;
1191 sym = OP_SYMBOL (op);
1192 if (sym->isspilt) return;
1193 if (!sym->nRegs) return;
1194 if (sym->regs[0]) return;
1196 werrorfl (ic->filename, ic->lineno, W_LOCAL_NOINIT,
1197 sym->prereqv ? sym->prereqv->name : sym->name);
1203 /*-----------------------------------------------------------------*/
1204 /* serialRegAssign - serially allocate registers to the variables */
1205 /*-----------------------------------------------------------------*/
1207 serialRegAssign (eBBlock ** ebbs, int count)
1211 /* for all blocks */
1212 for (i = 0; i < count; i++) {
1216 if (ebbs[i]->noPath &&
1217 (ebbs[i]->entryLabel != entryLabel &&
1218 ebbs[i]->entryLabel != returnLabel))
1221 /* of all instructions do */
1222 for (ic = ebbs[i]->sch; ic; ic = ic->next) {
1226 // update the registers in use at the start of this icode
1227 for (reg=0; reg<hc08_nRegs; reg++) {
1228 if (regshc08[reg].isFree) {
1229 ic->riu &= ~(regshc08[reg].mask);
1231 ic->riu |= (regshc08[reg].mask);
1236 /* if this is an ipop that means some live
1237 range will have to be assigned again */
1239 reassignLR (IC_LEFT (ic));
1241 /* if result is present && is a true symbol */
1242 if (IC_RESULT (ic) && ic->op != IFX &&
1243 IS_TRUE_SYMOP (IC_RESULT (ic)))
1244 OP_SYMBOL (IC_RESULT (ic))->allocreq++;
1246 /* take away registers from live
1247 ranges that end at this instruction */
1248 deassignLRs (ic, ebbs[i]);
1250 /* some don't need registers */
1251 if (SKIP_IC2 (ic) ||
1252 ic->op == JUMPTABLE ||
1256 (IC_RESULT (ic) && POINTER_SET (ic)))
1259 /* now we need to allocate registers
1260 only for the result */
1261 if (IC_RESULT (ic)) {
1262 symbol *sym = OP_SYMBOL (IC_RESULT (ic));
1268 /* Make sure any spill location is definately allocated */
1269 if (sym->isspilt && !sym->remat && sym->usl.spillLoc &&
1270 !sym->usl.spillLoc->allocreq) {
1271 sym->usl.spillLoc->allocreq++;
1274 /* if it does not need or is spilt
1275 or is already assigned to registers
1276 or will not live beyond this instructions */
1279 bitVectBitValue (_G.regAssigned, sym->key) ||
1280 sym->liveTo <= ic->seq)
1283 /* if some liverange has been spilt at the block level
1284 and this one live beyond this block then spil this
1286 if (_G.blockSpil && sym->liveTo > ebbs[i]->lSeq) {
1290 /* if trying to allocate this will cause
1291 a spill and there is nothing to spill
1292 or this one is rematerializable then
1294 willCS = willCauseSpill (sym->nRegs, sym->regType);
1295 spillable = computeSpillable (ic);
1296 if (sym->remat || (willCS && bitVectIsZero (spillable))) {
1301 /* If the live range preceeds the point of definition
1302 then ideally we must take into account registers that
1303 have been allocated after sym->liveFrom but freed
1304 before ic->seq. This is complicated, so spill this
1305 symbol instead and let fillGaps handle the allocation. */
1306 if (sym->liveFrom < ic->seq) {
1311 /* if it has a spillocation & is used less than
1312 all other live ranges then spill this */
1314 if (sym->usl.spillLoc) {
1315 symbol *leastUsed = leastUsedLR (liveRangesWith (spillable,
1316 allLRs, ebbs[i], ic));
1317 if (leastUsed && leastUsed->used > sym->used) {
1322 /* if none of the liveRanges have a spillLocation then better
1323 to spill this one than anything else already assigned to registers */
1324 if (liveRangesWith(spillable,noSpilLoc,ebbs[i],ic)) {
1325 /* if this is local to this block then we might find a block spil */
1326 if (!(sym->liveFrom >= ebbs[i]->fSeq && sym->liveTo <= ebbs[i]->lSeq)) {
1333 /* if we need ptr regs for the right side
1335 if (POINTER_GET (ic) && IS_SYMOP (IC_LEFT (ic))
1336 && getSize (OP_SYMBOL (IC_LEFT (ic))->type) <= (unsigned int) PTRSIZE) {
1340 /* else we assign registers to it */
1341 _G.regAssigned = bitVectSetBit (_G.regAssigned, sym->key);
1342 _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, sym->key);
1344 for (j = 0; j < sym->nRegs; j++) {
1345 if (sym->regType == REG_PTR)
1346 sym->regs[j] = getRegPtr (ic, ebbs[i], sym);
1348 sym->regs[j] = getRegGpr (ic, ebbs[i], sym);
1350 /* if the allocation failed which means
1351 this was spilt then break */
1352 if (!sym->regs[j]) {
1357 /* if it shares registers with operands make sure
1358 that they are in the same position */
1359 if (IC_LEFT (ic) && IS_SYMOP (IC_LEFT (ic)) &&
1360 OP_SYMBOL (IC_LEFT (ic))->nRegs && ic->op != '=') {
1361 positionRegs (OP_SYMBOL (IC_RESULT (ic)),
1362 OP_SYMBOL (IC_LEFT (ic)));
1364 /* do the same for the right operand */
1365 if (IC_RIGHT (ic) && IS_SYMOP (IC_RIGHT (ic)) &&
1366 OP_SYMBOL (IC_RIGHT (ic))->nRegs) {
1367 positionRegs (OP_SYMBOL (IC_RESULT (ic)),
1368 OP_SYMBOL (IC_RIGHT (ic)));
1380 /* Check for and fix any problems with uninitialized operands */
1381 for (i = 0; i < count; i++)
1385 if (ebbs[i]->noPath &&
1386 (ebbs[i]->entryLabel != entryLabel &&
1387 ebbs[i]->entryLabel != returnLabel))
1390 for (ic = ebbs[i]->sch; ic; ic = ic->next)
1397 verifyRegsAssigned (IC_COND (ic), ic);
1401 if (ic->op == JUMPTABLE)
1403 verifyRegsAssigned (IC_JTCOND (ic), ic);
1407 verifyRegsAssigned (IC_RESULT (ic), ic);
1408 verifyRegsAssigned (IC_LEFT (ic), ic);
1409 verifyRegsAssigned (IC_RIGHT (ic), ic);
1415 /*-----------------------------------------------------------------*/
1416 /* fillGaps - Try to fill in the Gaps left by Pass1 */
1417 /*-----------------------------------------------------------------*/
1418 static void fillGaps()
1423 if (getenv("DISABLE_FILL_GAPS")) return;
1425 /* look for liveranges that were spilt by the allocator */
1426 for (sym = hTabFirstItem(liveRanges,&key) ; sym ;
1427 sym = hTabNextItem(liveRanges,&key)) {
1432 if (!sym->spillA || !sym->clashes || sym->remat) continue ;
1434 /* find the liveRanges this one clashes with, that are
1435 still assigned to registers & mark the registers as used*/
1436 for ( i = 0 ; i < sym->clashes->size ; i ++) {
1440 if (bitVectBitValue(sym->clashes,i) == 0 || /* those that clash with this */
1441 bitVectBitValue(_G.totRegAssigned,i) == 0) /* and are still assigned to registers */
1444 clr = hTabItemWithKey(liveRanges,i);
1447 /* mark these registers as used */
1448 for (k = 0 ; k < clr->nRegs ; k++ )
1449 hc08_useReg(clr->regs[k]);
1452 if (willCauseSpill(sym->nRegs,sym->regType)) {
1453 /* NOPE :( clear all registers & and continue */
1458 /* THERE IS HOPE !!!! */
1459 for (i=0; i < sym->nRegs ; i++ ) {
1460 if (sym->regType == REG_PTR)
1461 sym->regs[i] = getRegPtrNoSpil ();
1463 sym->regs[i] = getRegGprNoSpil ();
1466 /* for all its definitions check if the registers
1467 allocated needs positioning NOTE: we can position
1468 only ONCE if more than One positioning required
1471 for (i = 0 ; i < sym->defs->size ; i++ ) {
1472 if (bitVectBitValue(sym->defs,i)) {
1474 if (!(ic = hTabItemWithKey(iCodehTab,i))) continue ;
1475 if (SKIP_IC(ic)) continue;
1476 assert(isSymbolEqual(sym,OP_SYMBOL(IC_RESULT(ic)))); /* just making sure */
1477 /* if left is assigned to registers */
1478 if (IS_SYMOP(IC_LEFT(ic)) &&
1479 bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_LEFT(ic))->key)) {
1480 pdone += positionRegs(sym,OP_SYMBOL(IC_LEFT(ic)));
1482 if (IS_SYMOP(IC_RIGHT(ic)) &&
1483 bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_RIGHT(ic))->key)) {
1484 pdone += positionRegs(sym,OP_SYMBOL(IC_RIGHT(ic)));
1486 if (pdone > 1) break;
1489 for (i = 0 ; i < sym->uses->size ; i++ ) {
1490 if (bitVectBitValue(sym->uses,i)) {
1492 if (!(ic = hTabItemWithKey(iCodehTab,i))) continue ;
1493 if (SKIP_IC(ic)) continue;
1494 if (!IS_ASSIGN_ICODE(ic)) continue ;
1496 /* if result is assigned to registers */
1497 if (IS_SYMOP(IC_RESULT(ic)) &&
1498 bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_RESULT(ic))->key)) {
1499 pdone += positionRegs(sym,OP_SYMBOL(IC_RESULT(ic)));
1501 if (pdone > 1) break;
1504 /* had to position more than once GIVE UP */
1506 /* UNDO all the changes we made to try this */
1508 for (i=0; i < sym->nRegs ; i++ ) {
1509 sym->regs[i] = NULL;
1512 D(printf ("Fill Gap gave up due to positioning for %s in function %s\n",sym->name, currFunc ? currFunc->name : "UNKNOWN"));
1515 D(printf ("FILLED GAP for %s in function %s\n",sym->name, currFunc ? currFunc->name : "UNKNOWN"));
1516 _G.totRegAssigned = bitVectSetBit(_G.totRegAssigned,sym->key);
1517 sym->isspilt = sym->spillA = 0 ;
1518 sym->usl.spillLoc->allocreq--;
1523 /*-----------------------------------------------------------------*/
1524 /* rUmaskForOp :- returns register mask for an operand */
1525 /*-----------------------------------------------------------------*/
1527 hc08_rUmaskForOp (operand * op)
1533 /* only temporaries are assigned registers */
1537 sym = OP_SYMBOL (op);
1539 /* if spilt or no registers assigned to it
1541 if (sym->isspilt || !sym->nRegs)
1544 rumask = newBitVect (hc08_nRegs);
1546 for (j = 0; j < sym->nRegs; j++)
1548 rumask = bitVectSetBit (rumask,
1549 sym->regs[j]->rIdx);
1555 /*-----------------------------------------------------------------*/
1556 /* regsUsedIniCode :- returns bit vector of registers used in iCode */
1557 /*-----------------------------------------------------------------*/
1559 regsUsedIniCode (iCode * ic)
1561 bitVect *rmask = newBitVect (hc08_nRegs);
1563 /* do the special cases first */
1566 rmask = bitVectUnion (rmask,
1567 hc08_rUmaskForOp (IC_COND (ic)));
1571 /* for the jumptable */
1572 if (ic->op == JUMPTABLE)
1574 rmask = bitVectUnion (rmask,
1575 hc08_rUmaskForOp (IC_JTCOND (ic)));
1580 /* of all other cases */
1582 rmask = bitVectUnion (rmask,
1583 hc08_rUmaskForOp (IC_LEFT (ic)));
1587 rmask = bitVectUnion (rmask,
1588 hc08_rUmaskForOp (IC_RIGHT (ic)));
1591 rmask = bitVectUnion (rmask,
1592 hc08_rUmaskForOp (IC_RESULT (ic)));
1598 /*-----------------------------------------------------------------*/
1599 /* createRegMask - for each instruction will determine the regsUsed */
1600 /*-----------------------------------------------------------------*/
1602 createRegMask (eBBlock ** ebbs, int count)
1606 /* for all blocks */
1607 for (i = 0; i < count; i++)
1611 if (ebbs[i]->noPath &&
1612 (ebbs[i]->entryLabel != entryLabel &&
1613 ebbs[i]->entryLabel != returnLabel))
1616 /* for all instructions */
1617 for (ic = ebbs[i]->sch; ic; ic = ic->next)
1622 if (SKIP_IC2 (ic) || !ic->rlive)
1625 /* first mark the registers used in this
1627 ic->rUsed = regsUsedIniCode (ic);
1628 _G.funcrUsed = bitVectUnion (_G.funcrUsed, ic->rUsed);
1630 /* now create the register mask for those
1631 registers that are in use : this is a
1632 super set of ic->rUsed */
1633 ic->rMask = newBitVect (hc08_nRegs + 1);
1635 /* for all live Ranges alive at this point */
1636 for (j = 1; j < ic->rlive->size; j++)
1641 /* if not alive then continue */
1642 if (!bitVectBitValue (ic->rlive, j))
1645 /* find the live range we are interested in */
1646 if (!(sym = hTabItemWithKey (liveRanges, j)))
1648 werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
1649 "createRegMask cannot find live range");
1650 fprintf(stderr, "\tmissing live range: key=%d\n", j);
1654 /* if no register assigned to it */
1655 if (!sym->nRegs || sym->isspilt)
1658 /* for all the registers allocated to it */
1659 for (k = 0; k < sym->nRegs; k++)
1662 bitVectSetBit (ic->rMask, sym->regs[k]->rIdx);
1668 /*-----------------------------------------------------------------*/
1669 /* rematStr - returns the rematerialized string for a remat var */
1670 /*-----------------------------------------------------------------*/
1672 rematStr (symbol * sym)
1674 iCode *ic = sym->rematiCode;
1679 /* if plus adjust offset to right hand side */
1682 offset += (int) operandLitValue (IC_RIGHT (ic));
1683 ic = OP_SYMBOL (IC_LEFT (ic))->rematiCode;
1687 /* if minus adjust offset to right hand side */
1690 offset -= (int) operandLitValue (IC_RIGHT (ic));
1691 ic = OP_SYMBOL (IC_LEFT (ic))->rematiCode;
1695 /* cast then continue */
1696 if (IS_CAST_ICODE(ic)) {
1697 ic = OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
1700 /* we reached the end */
1704 if (ic->op == ADDRESS_OF)
1708 SNPRINTF (buffer, sizeof(buffer),
1710 OP_SYMBOL (IC_LEFT (ic))->rname,
1711 offset >= 0 ? '+' : '-',
1712 abs (offset) & 0xffff);
1716 strncpyz (buffer, OP_SYMBOL (IC_LEFT (ic))->rname, sizeof(buffer));
1719 else if (ic->op == '=')
1721 offset += (int) operandLitValue (IC_RIGHT (ic));
1722 SNPRINTF (buffer, sizeof(buffer),
1729 /*-----------------------------------------------------------------*/
1730 /* regTypeNum - computes the type & number of registers required */
1731 /*-----------------------------------------------------------------*/
1733 regTypeNum (eBBlock *ebbs)
1739 /* for each live range do */
1740 for (sym = hTabFirstItem (liveRanges, &k); sym;
1741 sym = hTabNextItem (liveRanges, &k))
1744 /* if used zero times then no registers needed */
1745 if ((sym->liveTo - sym->liveFrom) == 0)
1749 /* if the live range is a temporary */
1753 /* if the type is marked as a conditional */
1754 if (sym->regType == REG_CND)
1757 /* if used in return only then we don't
1759 if (sym->ruonly || sym->accuse)
1761 if (IS_AGGREGATE (sym->type) || sym->isptr)
1762 sym->type = aggrToPtr (sym->type, FALSE);
1766 /* if the symbol has only one definition &
1767 that definition is a get_pointer */
1768 if (bitVectnBitsOn (sym->defs) == 1 &&
1769 (ic = hTabItemWithKey (iCodehTab,
1770 bitVectFirstBit (sym->defs))) &&
1772 !IS_BITVAR (sym->etype) &&
1773 (aggrToPtrDclType (operandType (IC_LEFT (ic)), FALSE) == POINTER))
1776 if (ptrPseudoSymSafe (sym, ic))
1778 ptrPseudoSymConvert (sym, ic, rematStr (OP_SYMBOL (IC_LEFT (ic))));
1782 /* if in data space or idata space then try to
1783 allocate pointer register */
1787 /* if not then we require registers */
1788 sym->nRegs = ((IS_AGGREGATE (sym->type) || sym->isptr) ?
1789 getSize (sym->type = aggrToPtr (sym->type, FALSE)) :
1790 getSize (sym->type));
1794 fprintf (stderr, "allocated more than 4 or 0 registers for type ");
1795 printTypeChain (sym->type, stderr);
1796 fprintf (stderr, "\n");
1799 /* determine the type of register required */
1800 if (sym->nRegs == 1 &&
1801 IS_PTR (sym->type) &&
1803 sym->regType = REG_PTR;
1805 sym->regType = REG_GPR;
1809 /* for the first run we don't provide */
1810 /* registers for true symbols we will */
1811 /* see how things go */
1817 /*-----------------------------------------------------------------*/
1818 /* freeAllRegs - mark all registers as free */
1819 /*-----------------------------------------------------------------*/
1825 for (i = 0; i < hc08_nRegs; i++) {
1826 regshc08[i].isFree = 1;
1827 regshc08[i].aop = NULL;
1831 /*-----------------------------------------------------------------*/
1832 /* deallocStackSpil - this will set the stack pointer back */
1833 /*-----------------------------------------------------------------*/
1835 DEFSETFUNC (deallocStackSpil)
1844 /*-----------------------------------------------------------------*/
1845 /* farSpacePackable - returns the packable icode for far variables */
1846 /*-----------------------------------------------------------------*/
1848 farSpacePackable (iCode * ic)
1852 /* go thru till we find a definition for the
1853 symbol on the right */
1854 for (dic = ic->prev; dic; dic = dic->prev)
1856 /* if the definition is a call then no */
1857 if ((dic->op == CALL || dic->op == PCALL) &&
1858 IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
1863 /* if shift by unknown amount then not */
1864 if ((dic->op == LEFT_OP || dic->op == RIGHT_OP) &&
1865 IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
1869 /* if pointer get and size > 1 */
1870 if (POINTER_GET (dic) &&
1871 getSize (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)) > 1)
1874 if (POINTER_SET (dic) &&
1875 getSize (aggrToPtr (operandType (IC_RESULT (dic)), FALSE)) > 1)
1879 /* if any three is a true symbol in far space */
1880 if (IC_RESULT (dic) &&
1881 IS_TRUE_SYMOP (IC_RESULT (dic)) /* &&
1882 isOperandInFarSpace (IC_RESULT (dic)) */)
1885 if (IC_RIGHT (dic) &&
1886 IS_TRUE_SYMOP (IC_RIGHT (dic)) /* &&
1887 isOperandInFarSpace (IC_RIGHT (dic)) */ &&
1888 !isOperandEqual (IC_RIGHT (dic), IC_RESULT (ic)))
1891 if (IC_LEFT (dic) &&
1892 IS_TRUE_SYMOP (IC_LEFT (dic)) /* &&
1893 isOperandInFarSpace (IC_LEFT (dic)) */ &&
1894 !isOperandEqual (IC_LEFT (dic), IC_RESULT (ic)))
1897 if (isOperandEqual (IC_RIGHT (ic), IC_RESULT (dic)))
1899 if ((dic->op == LEFT_OP ||
1900 dic->op == RIGHT_OP ||
1902 IS_OP_LITERAL (IC_RIGHT (dic)))
1915 packRegsForLiteral (iCode * ic)
1922 if (POINTER_SET (ic))
1924 if (!IS_LITERAL (getSpec (operandType (IC_RIGHT (ic)))))
1926 if (bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) > 1)
1929 for (k=0; k< OP_USES (IC_RESULT (ic))->size; k++)
1930 if (bitVectBitValue (OP_USES (IC_RESULT (ic)), k))
1932 uic = hTabItemWithKey (iCodehTab, k);
1935 if (uic->op != IFX && uic->op != JUMPTABLE)
1937 if (IC_LEFT (uic) && IC_LEFT (uic)->key == IC_RESULT (ic)->key)
1938 ReplaceOpWithCheaperOp(&IC_LEFT(uic), IC_RIGHT(ic));
1939 if (IC_RIGHT (uic) && IC_RIGHT (uic)->key == IC_RESULT (ic)->key)
1940 ReplaceOpWithCheaperOp(&IC_RIGHT(uic), IC_RIGHT(ic));
1941 if (IC_RESULT (uic) && IC_RESULT (uic)->key == IC_RESULT (ic)->key)
1942 ReplaceOpWithCheaperOp(&IC_RESULT(uic), IC_RIGHT(ic));
1950 /*-----------------------------------------------------------------*/
1951 /* packRegsForAssign - register reduction for assignment */
1952 /*-----------------------------------------------------------------*/
1954 packRegsForAssign (iCode * ic, eBBlock * ebp)
1958 if (!IS_ITEMP (IC_RIGHT (ic)) ||
1959 OP_SYMBOL (IC_RIGHT (ic))->isind ||
1960 OP_LIVETO (IC_RIGHT (ic)) > ic->seq)
1965 /* if the true symbol is defined in far space or on stack
1966 then we should not since this will increase register pressure */
1968 if (isOperandInFarSpace(IC_RESULT(ic)) && !farSpacePackable(ic)) {
1973 /* find the definition of iTempNN scanning backwards if we find a
1974 a use of the true symbol in before we find the definition then
1976 for (dic = ic->prev; dic; dic = dic->prev)
1979 #if 0 /* jwk: This collides with 1.43 but I really see no need for
1980 this anymore. It fixes bug #716790 and substantially improves
1981 redundant register usage around function calls.
1984 /* if there is a function call then don't pack it */
1985 if ((dic->op == CALL || dic->op == PCALL))
1991 /* Don't move an assignment out of a critical block */
1992 if (dic->op == CRITICAL)
2001 if (IS_TRUE_SYMOP (IC_RESULT (dic)) &&
2002 IS_OP_VOLATILE (IC_RESULT (dic)))
2008 if (IS_SYMOP (IC_RESULT (dic)) &&
2009 IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
2011 if (POINTER_SET (dic))
2017 if (IS_SYMOP (IC_RIGHT (dic)) &&
2018 (IC_RIGHT (dic)->key == IC_RESULT (ic)->key ||
2019 IC_RIGHT (dic)->key == IC_RIGHT (ic)->key))
2025 if (IS_SYMOP (IC_LEFT (dic)) &&
2026 (IC_LEFT (dic)->key == IC_RESULT (ic)->key ||
2027 IC_LEFT (dic)->key == IC_RIGHT (ic)->key))
2033 if (POINTER_SET (dic) &&
2034 IC_RESULT (dic)->key == IC_RESULT (ic)->key)
2042 return 0; /* did not find */
2044 /* if assignment then check that right is not a bit */
2045 if (ASSIGNMENT (ic) && !POINTER_SET (ic))
2047 sym_link *etype = operandType (IC_RESULT (dic));
2048 if (IS_BITFIELD (etype))
2050 /* if result is a bit too then it's ok */
2051 etype = operandType (IC_RESULT (ic));
2052 if (!IS_BITFIELD (etype))
2058 /* if the result is on stack or iaccess then it must be
2059 the same atleast one of the operands */
2060 if (OP_SYMBOL (IC_RESULT (ic))->onStack ||
2061 OP_SYMBOL (IC_RESULT (ic))->iaccess)
2064 /* the operation has only one symbol
2065 operator then we can pack */
2066 if ((IC_LEFT (dic) && !IS_SYMOP (IC_LEFT (dic))) ||
2067 (IC_RIGHT (dic) && !IS_SYMOP (IC_RIGHT (dic))))
2070 if (!((IC_LEFT (dic) &&
2071 IC_RESULT (ic)->key == IC_LEFT (dic)->key) ||
2073 IC_RESULT (ic)->key == IC_RIGHT (dic)->key)))
2077 /* found the definition */
2078 /* replace the result with the result of */
2079 /* this assignment and remove this assignment */
2080 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2081 ReplaceOpWithCheaperOp(&IC_RESULT (dic), IC_RESULT (ic));
2083 if (IS_ITEMP (IC_RESULT (dic)) && OP_SYMBOL (IC_RESULT (dic))->liveFrom > dic->seq)
2085 OP_SYMBOL (IC_RESULT (dic))->liveFrom = dic->seq;
2087 // TODO: and the otherway around?
2089 /* delete from liverange table also
2090 delete from all the points inbetween and the new
2092 for (sic = dic; sic != ic; sic = sic->next)
2094 bitVectUnSetBit (sic->rlive, IC_RESULT (ic)->key);
2095 if (IS_ITEMP (IC_RESULT (dic)))
2096 bitVectSetBit (sic->rlive, IC_RESULT (dic)->key);
2099 remiCodeFromeBBlock (ebp, ic);
2100 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
2101 hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
2102 OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
2107 /*------------------------------------------------------------------*/
2108 /* findAssignToSym : scanning backwards looks for first assig found */
2109 /*------------------------------------------------------------------*/
2111 findAssignToSym (operand * op, iCode * ic)
2115 /* This routine is used to find sequences like
2117 ...; (intervening ops don't use iTempAA or modify FOO)
2118 blah = blah + iTempAA;
2120 and eliminate the use of iTempAA, freeing up its register for
2125 for (dic = ic->prev; dic; dic = dic->prev)
2128 /* if definition by assignment */
2129 if (dic->op == '=' &&
2130 !POINTER_SET (dic) &&
2131 IC_RESULT (dic)->key == op->key
2132 && IS_TRUE_SYMOP(IC_RIGHT(dic))
2134 break; /* found where this temp was defined */
2136 /* if we find an usage then we cannot delete it */
2137 if (IC_LEFT (dic) && IC_LEFT (dic)->key == op->key)
2140 if (IC_RIGHT (dic) && IC_RIGHT (dic)->key == op->key)
2143 if (POINTER_SET (dic) && IC_RESULT (dic)->key == op->key)
2148 return NULL; /* didn't find any assignment to op */
2150 /* we are interested only if defined in far space */
2151 /* or in stack space in case of + & - */
2153 /* if assigned to a non-symbol then don't repack regs */
2154 if (!IS_SYMOP (IC_RIGHT (dic)))
2157 /* if the symbol is volatile then we should not */
2158 if (isOperandVolatile (IC_RIGHT (dic), TRUE))
2160 /* XXX TODO --- should we be passing FALSE to isOperandVolatile()?
2161 What does it mean for an iTemp to be volatile, anyway? Passing
2162 TRUE is more cautious but may prevent possible optimizations */
2164 /* if the symbol is in far space then we should not */
2165 /* if (isOperandInFarSpace (IC_RIGHT (dic)))
2168 /* for + & - operations make sure that
2169 if it is on the stack it is the same
2170 as one of the three operands */
2172 if ((ic->op == '+' || ic->op == '-') &&
2173 OP_SYMBOL (IC_RIGHT (dic))->onStack)
2176 if (IC_RESULT (ic)->key != IC_RIGHT (dic)->key &&
2177 IC_LEFT (ic)->key != IC_RIGHT (dic)->key &&
2178 IC_RIGHT (ic)->key != IC_RIGHT (dic)->key)
2183 /* now make sure that the right side of dic
2184 is not defined between ic & dic */
2187 iCode *sic = dic->next;
2189 for (; sic != ic; sic = sic->next)
2190 if (IC_RESULT (sic) &&
2191 IC_RESULT (sic)->key == IC_RIGHT (dic)->key)
2198 /*-----------------------------------------------------------------*/
2199 /* reassignAliasedSym - used by packRegsForSupport to replace */
2200 /* redundant iTemp with equivalent symbol */
2201 /*-----------------------------------------------------------------*/
2203 reassignAliasedSym (eBBlock *ebp, iCode *assignment, iCode *use, operand *op)
2206 unsigned oldSymKey, newSymKey;
2208 oldSymKey = op->key;
2209 newSymKey = IC_RIGHT(assignment)->key;
2211 /* only track live ranges of compiler-generated temporaries */
2212 if (!IS_ITEMP(IC_RIGHT(assignment)))
2215 /* update the live-value bitmaps */
2216 for (ic = assignment; ic != use; ic = ic->next) {
2217 bitVectUnSetBit (ic->rlive, oldSymKey);
2219 ic->rlive = bitVectSetBit (ic->rlive, newSymKey);
2222 /* update the sym of the used operand */
2223 OP_SYMBOL(op) = OP_SYMBOL(IC_RIGHT(assignment));
2224 op->key = OP_SYMBOL(op)->key;
2226 /* update the sym's liverange */
2227 if ( OP_LIVETO(op) < ic->seq )
2228 setToRange(op, ic->seq, FALSE);
2230 /* remove the assignment iCode now that its result is unused */
2231 remiCodeFromeBBlock (ebp, assignment);
2232 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(assignment))->defs, assignment->key);
2233 hTabDeleteItem (&iCodehTab, assignment->key, assignment, DELETE_ITEM, NULL);
2237 /*-----------------------------------------------------------------*/
2238 /* packRegsForSupport :- reduce some registers for support calls */
2239 /*-----------------------------------------------------------------*/
2241 packRegsForSupport (iCode * ic, eBBlock * ebp)
2246 /* for the left & right operand :- look to see if the
2247 left was assigned a true symbol in far space in that
2248 case replace them */
2250 if (IS_ITEMP (IC_LEFT (ic)) &&
2251 OP_SYMBOL (IC_LEFT (ic))->liveTo <= ic->seq)
2253 dic = findAssignToSym (IC_LEFT (ic), ic);
2257 /* found it we need to remove it from the block */
2258 reassignAliasedSym (ebp, dic, ic, IC_LEFT(ic));
2263 /* do the same for the right operand */
2264 if (IS_ITEMP (IC_RIGHT (ic)) &&
2265 OP_SYMBOL (IC_RIGHT (ic))->liveTo <= ic->seq)
2267 iCode *dic = findAssignToSym (IC_RIGHT (ic), ic);
2271 /* found it we need to remove it from the block */
2272 reassignAliasedSym (ebp, dic, ic, IC_RIGHT(ic));
2280 #define IS_OP_RUONLY(x) (x && IS_SYMOP(x) && OP_SYMBOL(x)->ruonly)
2284 /*-----------------------------------------------------------------*/
2285 /* packRegsForOneuse : - will reduce some registers for single Use */
2286 /*-----------------------------------------------------------------*/
2288 packRegsForOneuse (iCode * ic, operand * op, eBBlock * ebp)
2293 /* if returning a literal then do nothing */
2297 /* only up to 2 bytes */
2298 if (getSize (operandType (op)) > (fReturnSizeHC08 - 2))
2303 if (ic->op != SEND //RETURN
2305 && !POINTER_SET (ic)
2306 && !POINTER_GET (ic) )
2309 if (ic->op == SEND && ic->argreg != 1) return NULL;
2311 /* this routine will mark the a symbol as used in one
2312 instruction use only && if the defintion is local
2313 (ie. within the basic block) && has only one definition &&
2314 that definiion is either a return value from a
2315 function or does not contain any variables in
2317 uses = bitVectCopy (OP_USES (op));
2318 bitVectUnSetBit (uses, ic->key); /* take away this iCode */
2319 if (!bitVectIsZero (uses)) /* has other uses */
2322 /* if it has only one defintion */
2323 if (bitVectnBitsOn (OP_DEFS (op)) > 1)
2324 return NULL; /* has more than one definition */
2326 /* get that definition */
2328 hTabItemWithKey (iCodehTab,
2329 bitVectFirstBit (OP_DEFS (op)))))
2332 /* if that only usage is a cast */
2333 if (dic->op == CAST) {
2334 /* to a bigger type */
2335 if (getSize(OP_SYM_TYPE(IC_RESULT(dic))) >
2336 getSize(OP_SYM_TYPE(IC_RIGHT(dic)))) {
2337 /* than we can not, since we cannot predict the usage of b & acc */
2342 /* found the definition now check if it is local */
2343 if (dic->seq < ebp->fSeq ||
2344 dic->seq > ebp->lSeq)
2345 return NULL; /* non-local */
2347 /* now check if it is the return from
2349 if (dic->op == CALL || dic->op == PCALL)
2351 if (ic->op != SEND && ic->op != RETURN &&
2352 !POINTER_SET(ic) && !POINTER_GET(ic))
2354 OP_SYMBOL (op)->ruonly = 1;
2361 /* otherwise check that the definition does
2362 not contain any symbols in far space */
2363 // if (isOperandInFarSpace (IC_LEFT (dic)) ||
2364 // isOperandInFarSpace (IC_RIGHT (dic)) ||
2365 // IS_OP_RUONLY (IC_LEFT (ic)) ||
2366 // IS_OP_RUONLY (IC_RIGHT (ic)))
2371 /* if pointer set then make sure the pointer
2374 if (POINTER_SET (dic) &&
2375 !IS_DATA_PTR (aggrToPtr (operandType (IC_RESULT (dic)), FALSE)))
2378 if (POINTER_GET (dic) &&
2379 !IS_DATA_PTR (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)))
2385 /* also make sure the intervenening instructions
2386 don't have any thing in far space */
2387 for (dic = dic->next; dic && dic != ic && sic != ic; dic = dic->next)
2390 /* if there is an intervening function call then no */
2391 if (dic->op == CALL || dic->op == PCALL)
2393 /* if pointer set then make sure the pointer
2396 if (POINTER_SET (dic) &&
2397 !IS_DATA_PTR (aggrToPtr (operandType (IC_RESULT (dic)), FALSE)))
2400 if (POINTER_GET (dic) &&
2401 !IS_DATA_PTR (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)))
2404 /* if address of & the result is remat the okay */
2405 if (dic->op == ADDRESS_OF &&
2406 OP_SYMBOL (IC_RESULT (dic))->remat)
2409 /* if operand has size of three or more & this
2410 operation is a '*','/' or '%' then 'b' may
2413 if ((dic->op == '%' || dic->op == '/' || dic->op == '*') &&
2414 getSize (operandType (op)) >= 3)
2418 /* if left or right or result is in far space */
2419 // if (isOperandInFarSpace (IC_LEFT (dic)) ||
2420 // isOperandInFarSpace (IC_RIGHT (dic)) ||
2421 // isOperandInFarSpace (IC_RESULT (dic)) ||
2422 // IS_OP_RUONLY (IC_LEFT (dic)) ||
2423 // IS_OP_RUONLY (IC_RIGHT (dic)) ||
2424 // IS_OP_RUONLY (IC_RESULT (dic)))
2428 // /* if left or right or result is on stack */
2429 // if (isOperandOnStack(IC_LEFT(dic)) ||
2430 // isOperandOnStack(IC_RIGHT(dic)) ||
2431 // isOperandOnStack(IC_RESULT(dic))) {
2436 OP_SYMBOL (op)->ruonly = 1;
2441 /*-----------------------------------------------------------------*/
2442 /* isBitwiseOptimizable - requirements of JEAN LOUIS VERN */
2443 /*-----------------------------------------------------------------*/
2445 isBitwiseOptimizable (iCode * ic)
2447 sym_link *ltype = getSpec (operandType (IC_LEFT (ic)));
2448 sym_link *rtype = getSpec (operandType (IC_RIGHT (ic)));
2450 /* bitwise operations are considered optimizable
2451 under the following conditions (Jean-Louis VERN)
2463 if (IS_LITERAL(rtype) ||
2464 (IS_BITVAR (ltype) && IN_BITSPACE (SPEC_OCLS (ltype))))
2470 /*-----------------------------------------------------------------*/
2471 /* isCommutativeOp - tests whether this op cares what order its */
2472 /* operands are in */
2473 /*-----------------------------------------------------------------*/
2474 bool isCommutativeOp2(unsigned int op)
2476 if (op == '+' || op == '*' || op == EQ_OP ||
2477 op == '^' || op == '|' || op == BITWISEAND)
2483 /*-----------------------------------------------------------------*/
2484 /* operandUsesAcc2 - determines whether the code generated for this */
2485 /* operand will have to use the accumulator */
2486 /*-----------------------------------------------------------------*/
2487 bool operandUsesAcc2(operand *op)
2493 symbol *sym = OP_SYMBOL(op);
2497 return TRUE; /* duh! */
2499 // if (IN_STACK(sym->etype) || sym->onStack ||
2500 // (SPIL_LOC(op) && SPIL_LOC(op)->onStack))
2501 // return TRUE; /* acc is used to calc stack offset */
2506 sym = SPIL_LOC(op); /* if spilled, look at spill location */
2508 return FALSE; /* more checks? */
2512 symspace = SPEC_OCLS(sym->etype);
2514 // if (sym->iaccess && symspace->paged)
2515 // return TRUE; /* must fetch paged indirect sym via accumulator */
2517 if (IN_BITSPACE(symspace))
2518 return TRUE; /* fetching bit vars uses the accumulator */
2520 if (IN_FARSPACE(symspace) || IN_CODESPACE(symspace))
2521 return TRUE; /* fetched via accumulator and dptr */
2527 /*-----------------------------------------------------------------*/
2528 /* canDefAccResult - return 1 if the iCode can generate a result */
2530 /*-----------------------------------------------------------------*/
2532 canDefAccResult (iCode * ic)
2536 if (ic->op == IFX || ic->op == JUMPTABLE) /* these iCodes have no result */
2539 if (POINTER_SET (ic))
2542 if (!IC_RESULT (ic))
2545 if (!IS_ITEMP (IC_RESULT (ic)))
2548 /* I don't think an iTemp can be an aggregate, but just in case */
2549 if (IS_AGGREGATE(operandType(IC_RESULT(ic))))
2552 size = getSize (operandType (IC_RESULT (ic)));
2556 /* All 1 byte operations should safely generate an accumulator result */
2565 return isOperandLiteral (IC_RIGHT (ic))
2566 && SPEC_USIGN (operandType (IC_RESULT (ic)));
2571 case '=': /* assignment, since POINTER_SET is already ruled out */
2582 /*-----------------------------------------------------------------*/
2583 /* canUseAccOperand - return 1 if the iCode can use the operand */
2584 /* when passed in A or XA */
2585 /*-----------------------------------------------------------------*/
2587 canUseAccOperand (iCode * ic, operand * op)
2594 if (isOperandEqual (op, IC_COND (ic)))
2600 if (ic->op == JUMPTABLE)
2602 if (isOperandEqual (op, IC_JTCOND (ic)))
2608 if (POINTER_SET (ic) && isOperandEqual (op, IC_RESULT (ic)))
2611 if (isOperandEqual (op, IC_LEFT (ic)))
2612 otherOp = IC_RIGHT (ic);
2613 else if (isOperandEqual (op, IC_RIGHT (ic)))
2614 otherOp = IC_LEFT (ic);
2618 /* Generation of SEND is deferred until CALL; not safe */
2619 /* if there are intermediate iCodes */
2620 if (ic->op == SEND && ic->next && ic->next->op != CALL)
2623 size = getSize (operandType (op));
2626 /* All 1 byte operations should safely use an accumulator operand */
2635 return isOperandLiteral (IC_RIGHT (ic));
2647 /*-----------------------------------------------------------------*/
2648 /* packRegsForAccUse - pack registers for acc use */
2649 /*-----------------------------------------------------------------*/
2651 packRegsForAccUse (iCode * ic)
2656 if (!canDefAccResult (ic))
2659 op = IC_RESULT (ic);
2661 /* has only one definition */
2662 if (bitVectnBitsOn (OP_DEFS (op)) > 1)
2665 /* has only one use */
2666 if (bitVectnBitsOn (OP_USES (op)) > 1)
2673 if (!canUseAccOperand (uic, op))
2677 if ((POINTER_GET(uic))
2678 || (ic->op == ADDRESS_OF && uic->op == '+' && IS_OP_LITERAL (IC_RIGHT (uic))))
2680 OP_SYMBOL (IC_RESULT (ic))->accuse = ACCUSE_HX;
2685 OP_SYMBOL (IC_RESULT (ic))->accuse = ACCUSE_XA;
2689 /*-----------------------------------------------------------------*/
2690 /* packForPush - hueristics to reduce iCode for pushing */
2691 /*-----------------------------------------------------------------*/
2693 packForPush (iCode * ic, eBBlock ** ebpp, int blockno)
2697 struct eBBlock * ebp=ebpp[blockno];
2699 if (ic->op != IPUSH || !IS_ITEMP (IC_LEFT (ic)))
2702 /* must have only definition & one usage */
2703 if (bitVectnBitsOn (OP_DEFS (IC_LEFT (ic))) != 1 ||
2704 bitVectnBitsOn (OP_USES (IC_LEFT (ic))) != 1)
2707 /* find the definition */
2708 if (!(dic = hTabItemWithKey (iCodehTab,
2709 bitVectFirstBit (OP_DEFS (IC_LEFT (ic))))))
2712 if (dic->op != '=' || POINTER_SET (dic))
2715 if (dic->seq < ebp->fSeq) { // Evelyn did this
2717 for (i=0; i<blockno; i++) {
2718 if (dic->seq >= ebpp[i]->fSeq && dic->seq <= ebpp[i]->lSeq) {
2723 wassert (i!=blockno); // no way to recover from here
2726 if (IS_SYMOP(IC_RIGHT(dic))) {
2727 /* make sure the right side does not have any definitions
2729 dbv = OP_DEFS(IC_RIGHT(dic));
2730 for (lic = ic; lic && lic != dic ; lic = lic->prev) {
2731 if (bitVectBitValue(dbv,lic->key))
2734 /* make sure they have the same type */
2735 if (IS_SPEC(operandType(IC_LEFT(ic))))
2737 sym_link *itype=operandType(IC_LEFT(ic));
2738 sym_link *ditype=operandType(IC_RIGHT(dic));
2740 if (SPEC_USIGN(itype)!=SPEC_USIGN(ditype) ||
2741 SPEC_LONG(itype)!=SPEC_LONG(ditype))
2744 /* extend the live range of replaced operand if needed */
2745 if (OP_SYMBOL(IC_RIGHT(dic))->liveTo < ic->seq) {
2746 OP_SYMBOL(IC_RIGHT(dic))->liveTo = ic->seq;
2748 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2751 /* we now we know that it has one & only one def & use
2752 and the that the definition is an assignment */
2753 ReplaceOpWithCheaperOp(&IC_LEFT (ic), IC_RIGHT (dic));
2754 remiCodeFromeBBlock (ebp, dic);
2755 hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2758 /*-----------------------------------------------------------------*/
2759 /* packRegisters - does some transformations to reduce register */
2761 /*-----------------------------------------------------------------*/
2763 packRegisters (eBBlock ** ebpp, int blockno)
2767 eBBlock *ebp=ebpp[blockno];
2774 /* look for assignments of the form */
2775 /* iTempNN = TRueSym (someoperation) SomeOperand */
2777 /* TrueSym := iTempNN:1 */
2778 for (ic = ebp->sch; ic; ic = ic->next)
2780 /* find assignment of the form TrueSym := iTempNN:1 */
2781 if (ic->op == '=' && !POINTER_SET (ic) )
2782 change += packRegsForAssign (ic, ebp);
2789 for (ic = ebp->sch; ic; ic = ic->next)
2791 //packRegsForLiteral (ic);
2793 /* if this is an itemp & result of an address of a true sym
2794 then mark this as rematerialisable */
2795 if (ic->op == ADDRESS_OF &&
2796 IS_ITEMP (IC_RESULT (ic)) &&
2797 IS_TRUE_SYMOP (IC_LEFT (ic)) &&
2798 bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
2799 !OP_SYMBOL (IC_LEFT (ic))->onStack )
2802 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2803 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2804 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2808 if (ic->op == '=' &&
2809 !POINTER_SET (ic) &&
2810 IS_ITEMP (IC_RESULT (ic)) &&
2811 IS_VALOP (IC_RIGHT (ic)) &&
2812 bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1)
2815 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2816 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2817 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2821 /* if straight assignment then carry remat flag if
2822 this is the only definition */
2823 if (ic->op == '=' &&
2824 !POINTER_SET (ic) &&
2825 IS_SYMOP (IC_RIGHT (ic)) &&
2826 OP_SYMBOL (IC_RIGHT (ic))->remat &&
2827 !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode) &&
2828 bitVectnBitsOn (OP_SYMBOL (IC_RESULT (ic))->defs) <= 1)
2831 OP_SYMBOL (IC_RESULT (ic))->remat =
2832 OP_SYMBOL (IC_RIGHT (ic))->remat;
2833 OP_SYMBOL (IC_RESULT (ic))->rematiCode =
2834 OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
2837 /* if cast to a generic pointer & the pointer being
2838 cast is remat, then we can remat this cast as well */
2839 if (ic->op == CAST &&
2840 IS_SYMOP(IC_RIGHT(ic)) &&
2841 OP_SYMBOL(IC_RIGHT(ic))->remat &&
2842 bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1) {
2843 sym_link *to_type = operandType(IC_LEFT(ic));
2844 sym_link *from_type = operandType(IC_RIGHT(ic));
2845 if (IS_GENPTR(to_type) && IS_PTR(from_type)) {
2846 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2847 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2848 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2852 /* if this is a +/- operation with a rematerizable
2853 then mark this as rematerializable as well */
2854 if ((ic->op == '+' || ic->op == '-') &&
2855 (IS_SYMOP (IC_LEFT (ic)) &&
2856 IS_ITEMP (IC_RESULT (ic)) &&
2857 IS_OP_LITERAL (IC_RIGHT (ic))) &&
2858 OP_SYMBOL (IC_LEFT (ic))->remat &&
2859 (!IS_SYMOP (IC_RIGHT (ic)) || !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode)) &&
2860 bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1)
2862 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2863 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2864 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2867 /* mark the pointer usages */
2868 if (POINTER_SET (ic))
2869 OP_SYMBOL (IC_RESULT (ic))->uptr = 1;
2871 if (POINTER_GET (ic) &&
2872 IS_SYMOP(IC_LEFT (ic)))
2873 OP_SYMBOL (IC_LEFT (ic))->uptr = 1;
2878 /* if we are using a symbol on the stack
2879 then we should say hc08_ptrRegReq */
2880 if (ic->op == IFX && IS_SYMOP (IC_COND (ic)))
2881 hc08_ptrRegReq += ((OP_SYMBOL (IC_COND (ic))->onStack ||
2882 OP_SYMBOL (IC_COND (ic))->iaccess) ? 1 : 0);
2883 else if (ic->op == JUMPTABLE && IS_SYMOP (IC_JTCOND (ic)))
2884 hc08_ptrRegReq += ((OP_SYMBOL (IC_JTCOND (ic))->onStack ||
2885 OP_SYMBOL (IC_JTCOND (ic))->iaccess) ? 1 : 0);
2888 if (IS_SYMOP (IC_LEFT (ic)))
2889 hc08_ptrRegReq += ((OP_SYMBOL (IC_LEFT (ic))->onStack ||
2890 OP_SYMBOL (IC_LEFT (ic))->iaccess) ? 1 : 0);
2891 if (IS_SYMOP (IC_RIGHT (ic)))
2892 hc08_ptrRegReq += ((OP_SYMBOL (IC_RIGHT (ic))->onStack ||
2893 OP_SYMBOL (IC_RIGHT (ic))->iaccess) ? 1 : 0);
2894 if (IS_SYMOP (IC_RESULT (ic)))
2895 hc08_ptrRegReq += ((OP_SYMBOL (IC_RESULT (ic))->onStack ||
2896 OP_SYMBOL (IC_RESULT (ic))->iaccess) ? 1 : 0);
2901 /* if the condition of an if instruction
2902 is defined in the previous instruction and
2903 this is the only usage then
2904 mark the itemp as a conditional */
2905 if ((IS_CONDITIONAL (ic) ||
2906 (IS_BITWISE_OP(ic) && isBitwiseOptimizable (ic))) &&
2907 ic->next && ic->next->op == IFX &&
2908 bitVectnBitsOn (OP_USES(IC_RESULT(ic)))==1 &&
2909 isOperandEqual (IC_RESULT (ic), IC_COND (ic->next)) &&
2910 OP_SYMBOL (IC_RESULT (ic))->liveTo <= ic->next->seq)
2912 OP_SYMBOL (IC_RESULT (ic))->regType = REG_CND;
2917 /* if the condition of an if instruction
2918 is defined in the previous GET_POINTER instruction and
2919 this is the only usage then
2920 mark the itemp as accumulator use */
2921 if ((POINTER_GET (ic) && getSize (operandType (IC_RESULT (ic))) <=1) &&
2922 ic->next && ic->next->op == IFX &&
2923 bitVectnBitsOn (OP_USES(IC_RESULT(ic)))==1 &&
2924 isOperandEqual (IC_RESULT (ic), IC_COND (ic->next)) &&
2925 OP_SYMBOL (IC_RESULT (ic))->liveTo <= ic->next->seq)
2927 OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
2931 if (ic->op != IFX && ic->op !=JUMPTABLE && !POINTER_SET (ic)
2932 && IC_RESULT (ic) && IS_ITEMP (IC_RESULT (ic))
2933 && getSize (operandType (IC_RESULT (ic))) == 1
2934 && bitVectnBitsOn (OP_USES (IC_RESULT (ic))) == 1
2936 && OP_SYMBOL (IC_RESULT (ic))->liveTo <= ic->next->seq)
2940 if (ic->next->op == IFX)
2942 if (isOperandEqual (IC_RESULT (ic), IC_COND (ic->next)))
2945 else if (ic->next->op == JUMPTABLE)
2947 if (isOperandEqual (IC_RESULT (ic), IC_JTCOND (ic->next)))
2952 if (isOperandEqual (IC_RESULT (ic), IC_LEFT (ic->next)))
2954 if (isOperandEqual (IC_RESULT (ic), IC_RIGHT (ic->next)))
2960 OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
2967 /* reduce for support function calls */
2968 if (ic->supportRtn || (ic->op != IFX && ic->op != JUMPTABLE))
2969 packRegsForSupport (ic, ebp);
2972 /* some cases the redundant moves can
2973 can be eliminated for return statements */
2974 if ((ic->op == RETURN || (ic->op == SEND && ic->argreg == 1)) &&
2975 /* !isOperandInFarSpace (IC_LEFT (ic)) && */
2976 options.model == MODEL_SMALL) {
2977 packRegsForOneuse (ic, IC_LEFT (ic), ebp);
2980 /* if pointer set & left has a size more than
2981 one and right is not in far space */
2982 if (POINTER_SET (ic) &&
2983 /* !isOperandInFarSpace (IC_RIGHT (ic)) && */
2984 !OP_SYMBOL (IC_RESULT (ic))->remat &&
2985 !IS_OP_RUONLY (IC_RIGHT (ic))
2986 /* && getSize (aggrToPtr (operandType (IC_RESULT (ic)), FALSE)) > 1 */ )
2987 packRegsForOneuse (ic, IC_RESULT (ic), ebp);
2989 /* if pointer get */
2990 if (POINTER_GET (ic) &&
2991 IS_SYMOP (IC_LEFT (ic)) &&
2992 /* !isOperandInFarSpace (IC_RESULT (ic)) && */
2993 !OP_SYMBOL (IC_LEFT (ic))->remat &&
2994 !IS_OP_RUONLY (IC_RESULT (ic))
2995 /* && getSize (aggrToPtr (operandType (IC_LEFT (ic)), FALSE)) > 1 */)
2996 packRegsForOneuse (ic, IC_LEFT (ic), ebp);
2999 /* if this is cast for intergral promotion then
3000 check if only use of the definition of the
3001 operand being casted/ if yes then replace
3002 the result of that arithmetic operation with
3003 this result and get rid of the cast */
3006 sym_link *fromType = operandType (IC_RIGHT (ic));
3007 sym_link *toType = operandType (IC_LEFT (ic));
3009 if (IS_INTEGRAL (fromType) && IS_INTEGRAL (toType) &&
3010 getSize (fromType) != getSize (toType) &&
3011 SPEC_USIGN (fromType) == SPEC_USIGN (toType))
3014 iCode *dic = packRegsForOneuse (ic, IC_RIGHT (ic), ebp);
3017 if (IS_ARITHMETIC_OP (dic))
3019 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
3020 ReplaceOpWithCheaperOp(&IC_RESULT (dic), IC_RESULT (ic));
3021 remiCodeFromeBBlock (ebp, ic);
3022 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
3023 hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
3024 OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
3028 OP_SYMBOL (IC_RIGHT (ic))->ruonly = 0;
3034 /* if the type from and type to are the same
3035 then if this is the only use then packit */
3036 if (compareType (operandType (IC_RIGHT (ic)),
3037 operandType (IC_LEFT (ic))) == 1)
3039 iCode *dic = packRegsForOneuse (ic, IC_RIGHT (ic), ebp);
3042 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
3043 ReplaceOpWithCheaperOp(&IC_RESULT (dic), IC_RESULT (ic));
3044 remiCodeFromeBBlock (ebp, ic);
3045 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
3046 hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
3047 OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
3056 iTempNN := (some variable in farspace) V1
3061 if (ic->op == IPUSH)
3063 packForPush (ic, ebpp, blockno);
3066 packRegsForAccUse (ic);
3070 /*-----------------------------------------------------------------*/
3071 /* assignRegisters - assigns registers to each live range as need */
3072 /*-----------------------------------------------------------------*/
3074 hc08_assignRegisters (ebbIndex * ebbi)
3076 eBBlock ** ebbs = ebbi->bbOrder;
3077 int count = ebbi->count;
3081 setToNull ((void *) &_G.funcrUsed);
3082 setToNull ((void *) &_G.regAssigned);
3083 setToNull ((void *) &_G.totRegAssigned);
3084 hc08_ptrRegReq = _G.stackExtend = _G.dataExtend = 0;
3086 hc08_reg_a = hc08_regWithIdx(A_IDX);
3087 hc08_reg_x = hc08_regWithIdx(X_IDX);
3088 hc08_reg_h = hc08_regWithIdx(H_IDX);
3089 hc08_reg_hx = hc08_regWithIdx(HX_IDX);
3090 hc08_reg_xa = hc08_regWithIdx(XA_IDX);
3091 hc08_reg_sp = hc08_regWithIdx(SP_IDX);
3094 /* change assignments this will remove some
3095 live ranges reducing some register pressure */
3096 for (i = 0; i < count; i++)
3097 packRegisters (ebbs, i);
3099 /* liveranges probably changed by register packing
3100 so we compute them again */
3101 recomputeLiveRanges (ebbs, count);
3103 if (options.dump_pack)
3104 dumpEbbsToFileExt (DUMP_PACK, ebbi);
3106 /* first determine for each live range the number of
3107 registers & the type of registers required for each */
3110 /* and serially allocate registers */
3111 serialRegAssign (ebbs, count);
3114 //setToNull ((void *) &_G.regAssigned);
3115 //setToNull ((void *) &_G.totRegAssigned);
3118 /* if stack was extended then tell the user */
3121 /* werror(W_TOOMANY_SPILS,"stack", */
3122 /* _G.stackExtend,currFunc->name,""); */
3128 /* werror(W_TOOMANY_SPILS,"data space", */
3129 /* _G.dataExtend,currFunc->name,""); */
3133 /* after that create the register mask
3134 for each of the instruction */
3135 createRegMask (ebbs, count);
3137 /* redo that offsets for stacked automatic variables */
3139 redoStackOffsets ();
3142 if (options.dump_rassgn)
3144 dumpEbbsToFileExt (DUMP_RASSGN, ebbi);
3145 dumpLiveRanges (DUMP_LRANGE, liveRanges);
3148 /* do the overlaysegment stuff SDCCmem.c */
3149 doOverlays (ebbs, count);
3151 /* now get back the chain */
3152 ic = iCodeLabelOptimize (iCodeFromeBBlock (ebbs, count));
3156 /* free up any _G.stackSpil locations allocated */
3157 applyToSet (_G.stackSpil, deallocStackSpil);
3159 setToNull ((void *) &_G.stackSpil);
3160 setToNull ((void *) &_G.spiltSet);
3161 /* mark all registers as free */