1 /*------------------------------------------------------------------------
3 SDCCralloc.c - source file for register allocation. (8051) specific
5 Written By - Sandeep Dutta . sandeep.dutta@usa.net (1998)
7 This program is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 2, or (at your option) any
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21 In other words, you are welcome to use, share and improve this program.
22 You are forbidden to forbid anyone else to use, share and improve
23 what you give them. Help stamp out software-hoarding!
24 -------------------------------------------------------------------------*/
30 /*-----------------------------------------------------------------*/
31 /* At this point we start getting processor specific although */
32 /* some routines are non-processor specific & can be reused when */
33 /* targetting other processors. The decision for this will have */
34 /* to be made on a routine by routine basis */
35 /* routines used to pack registers are most definitely not reusable */
36 /* since the pack the registers depending strictly on the MCU */
37 /*-----------------------------------------------------------------*/
47 bitVect *totRegAssigned; /* final set of LRs that got into registers */
50 bitVect *funcrUsed; /* registers used in a function */
56 /* Shared with gen.c */
57 int ds390_ptrRegReq; /* one byte pointer register required */
63 {REG_GPR, R2_IDX, REG_GPR, "r2", "ar2", "0", 2, 1, 1},
64 {REG_GPR, R3_IDX, REG_GPR, "r3", "ar3", "0", 3, 1, 1},
65 {REG_GPR, R4_IDX, REG_GPR, "r4", "ar4", "0", 4, 1, 1},
66 {REG_GPR, R5_IDX, REG_GPR, "r5", "ar5", "0", 5, 1, 1},
67 {REG_GPR, R6_IDX, REG_GPR, "r6", "ar6", "0", 6, 1, 1},
68 {REG_GPR, R7_IDX, REG_GPR, "r7", "ar7", "0", 7, 1, 1},
69 {REG_PTR, R0_IDX, REG_PTR, "r0", "ar0", "0", 0, 1, 1},
70 {REG_PTR, R1_IDX, REG_PTR, "r1", "ar1", "0", 1, 1, 1},
71 {REG_GPR, DPL_IDX, REG_GPR, "dpl", "dpl", "dpl", 0, 0, 0},
72 {REG_GPR, DPH_IDX, REG_GPR, "dph", "dph", "dph", 0, 0, 0},
73 {REG_GPR, DPX_IDX, REG_GPR, "dpx", "dpx", "dpx", 0, 0, 0},
74 {REG_GPR, B_IDX, REG_GPR, "b", "b", "b", 0, 0, 0},
75 {REG_GPR, X8_IDX, REG_GPR, "x8", "x8", "xreg", 0, 0, 0},
76 {REG_GPR, X9_IDX, REG_GPR, "x9", "x9", "xreg", 1, 0, 0},
77 {REG_GPR, X10_IDX, REG_GPR, "x10", "x10", "xreg", 2, 0, 0},
78 {REG_GPR, X11_IDX, REG_GPR, "x11", "x11", "xreg", 3, 0, 0},
79 {REG_GPR, X12_IDX, REG_GPR, "x12", "x12", "xreg", 4, 0, 0},
80 {REG_CND, CND_IDX, REG_GPR, "C", "C", "xreg", 0, 0, 0},
83 static void spillThis (symbol *);
84 static void freeAllRegs ();
85 static iCode * packRegsDPTRuse (operand *);
86 static int packRegsDPTRnuse (operand *,int);
88 /*-----------------------------------------------------------------*/
89 /* allocReg - allocates register of given type */
90 /*-----------------------------------------------------------------*/
96 for (i = 0; i < ds390_nRegs; i++)
99 /* if type is given as 0 then any
100 free register will do */
104 regs390[i].isFree = 0;
107 bitVectSetBit (currFunc->regsUsed, i);
110 /* other wise look for specific type
112 if (regs390[i].isFree &&
113 regs390[i].type == type)
115 regs390[i].isFree = 0;
118 bitVectSetBit (currFunc->regsUsed, i);
125 /*-----------------------------------------------------------------*/
126 /* ds390_regWithIdx - returns pointer to register wit index number */
127 /*-----------------------------------------------------------------*/
129 ds390_regWithIdx (int idx)
133 for (i = 0; i < ds390_nRegs; i++)
134 if (regs390[i].rIdx == idx)
137 werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
138 "regWithIdx not found");
142 /*-----------------------------------------------------------------*/
143 /* freeReg - frees a register */
144 /*-----------------------------------------------------------------*/
151 /*-----------------------------------------------------------------*/
152 /* useReg - marks a register as used */
153 /*-----------------------------------------------------------------*/
161 /*-----------------------------------------------------------------*/
162 /* nFreeRegs - returns number of free registers */
163 /*-----------------------------------------------------------------*/
170 for (i = 0; i < ds390_nRegs; i++)
171 if (regs390[i].isFree && regs390[i].type == type)
176 /*-----------------------------------------------------------------*/
177 /* nfreeRegsType - free registers with type */
178 /*-----------------------------------------------------------------*/
180 nfreeRegsType (int type)
185 if ((nfr = nFreeRegs (type)) == 0)
186 return nFreeRegs (REG_GPR);
189 return nFreeRegs (type);
194 /*-----------------------------------------------------------------*/
195 /* isOperandInReg - returns true if operand is currently in regs */
196 /*-----------------------------------------------------------------*/
197 static int isOperandInReg(operand *op)
199 if (!IS_SYMOP(op)) return 0;
200 if (OP_SYMBOL(op)->ruonly) return 1;
201 if (OP_SYMBOL(op)->accuse) return 1;
202 if (OP_SYMBOL(op)->dptr) return 1;
203 return bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(op)->key);
206 /*-----------------------------------------------------------------*/
207 /* computeSpillable - given a point find the spillable live ranges */
208 /*-----------------------------------------------------------------*/
210 computeSpillable (iCode * ic)
214 /* spillable live ranges are those that are live at this
215 point . the following categories need to be subtracted
217 a) - those that are already spilt
218 b) - if being used by this one
219 c) - defined by this one */
221 spillable = bitVectCopy (ic->rlive);
223 bitVectCplAnd (spillable, _G.spiltSet); /* those already spilt */
225 bitVectCplAnd (spillable, ic->uses); /* used in this one */
226 bitVectUnSetBit (spillable, ic->defKey);
227 spillable = bitVectIntersect (spillable, _G.regAssigned);
232 /*-----------------------------------------------------------------*/
233 /* noSpilLoc - return true if a variable has no spil location */
234 /*-----------------------------------------------------------------*/
236 noSpilLoc (symbol * sym, eBBlock * ebp, iCode * ic)
238 return (sym->usl.spillLoc ? 0 : 1);
241 /*-----------------------------------------------------------------*/
242 /* hasSpilLoc - will return 1 if the symbol has spil location */
243 /*-----------------------------------------------------------------*/
245 hasSpilLoc (symbol * sym, eBBlock * ebp, iCode * ic)
247 return (sym->usl.spillLoc ? 1 : 0);
250 /*-----------------------------------------------------------------*/
251 /* directSpilLoc - will return 1 if the splilocation is in direct */
252 /*-----------------------------------------------------------------*/
254 directSpilLoc (symbol * sym, eBBlock * ebp, iCode * ic)
256 if (sym->usl.spillLoc &&
257 (IN_DIRSPACE (SPEC_OCLS (sym->usl.spillLoc->etype))))
263 /*-----------------------------------------------------------------*/
264 /* hasSpilLocnoUptr - will return 1 if the symbol has spil location */
265 /* but is not used as a pointer */
266 /*-----------------------------------------------------------------*/
268 hasSpilLocnoUptr (symbol * sym, eBBlock * ebp, iCode * ic)
270 return ((sym->usl.spillLoc && !sym->uptr) ? 1 : 0);
273 /*-----------------------------------------------------------------*/
274 /* rematable - will return 1 if the remat flag is set */
275 /*-----------------------------------------------------------------*/
277 rematable (symbol * sym, eBBlock * ebp, iCode * ic)
282 /*-----------------------------------------------------------------*/
283 /* notUsedInRemaining - not used or defined in remain of the block */
284 /*-----------------------------------------------------------------*/
286 notUsedInRemaining (symbol * sym, eBBlock * ebp, iCode * ic)
288 return ((usedInRemaining (operandFromSymbol (sym), ic) ? 0 : 1) &&
289 allDefsOutOfRange (sym->defs, ebp->fSeq, ebp->lSeq));
292 /*-----------------------------------------------------------------*/
293 /* allLRs - return true for all */
294 /*-----------------------------------------------------------------*/
296 allLRs (symbol * sym, eBBlock * ebp, iCode * ic)
301 /*-----------------------------------------------------------------*/
302 /* liveRangesWith - applies function to a given set of live range */
303 /*-----------------------------------------------------------------*/
305 liveRangesWith (bitVect * lrs, int (func) (symbol *, eBBlock *, iCode *),
306 eBBlock * ebp, iCode * ic)
311 if (!lrs || !lrs->size)
314 for (i = 1; i < lrs->size; i++)
317 if (!bitVectBitValue (lrs, i))
320 /* if we don't find it in the live range
321 hash table we are in serious trouble */
322 if (!(sym = hTabItemWithKey (liveRanges, i)))
324 werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
325 "liveRangesWith could not find liveRange");
329 if (func (sym, ebp, ic) && bitVectBitValue (_G.regAssigned, sym->key))
330 addSetHead (&rset, sym);
337 /*-----------------------------------------------------------------*/
338 /* leastUsedLR - given a set determines which is the least used */
339 /*-----------------------------------------------------------------*/
341 leastUsedLR (set * sset)
343 symbol *sym = NULL, *lsym = NULL;
345 sym = lsym = setFirstItem (sset);
350 for (; lsym; lsym = setNextItem (sset))
353 /* if usage is the same then prefer
354 the spill the smaller of the two */
355 if (lsym->used == sym->used)
356 if (getSize (lsym->type) < getSize (sym->type))
360 if (lsym->used < sym->used)
365 setToNull ((void *) &sset);
370 /*-----------------------------------------------------------------*/
371 /* noOverLap - will iterate through the list looking for over lap */
372 /*-----------------------------------------------------------------*/
374 noOverLap (set * itmpStack, symbol * fsym)
378 for (sym = setFirstItem (itmpStack); sym;
379 sym = setNextItem (itmpStack))
381 if (bitVectBitValue(sym->clashes,fsym->key)) return 0;
386 /*-----------------------------------------------------------------*/
387 /* isFree - will return 1 if the a free spil location is found */
388 /*-----------------------------------------------------------------*/
393 V_ARG (symbol **, sloc);
394 V_ARG (symbol *, fsym);
396 /* if already found */
400 /* if it is free && and the itmp assigned to
401 this does not have any overlapping live ranges
402 with the one currently being assigned and
403 the size can be accomodated */
405 noOverLap (sym->usl.itmpStack, fsym) &&
406 getSize (sym->type) >= getSize (fsym->type))
415 /*-----------------------------------------------------------------*/
416 /* spillLRWithPtrReg :- will spil those live ranges which use PTR */
417 /*-----------------------------------------------------------------*/
419 spillLRWithPtrReg (symbol * forSym)
425 if (!_G.regAssigned ||
426 bitVectIsZero (_G.regAssigned))
429 r0 = ds390_regWithIdx (R0_IDX);
430 r1 = ds390_regWithIdx (R1_IDX);
432 /* for all live ranges */
433 for (lrsym = hTabFirstItem (liveRanges, &k); lrsym;
434 lrsym = hTabNextItem (liveRanges, &k))
438 /* if no registers assigned to it or
440 /* if it does not overlap with this then
441 not need to spill it */
443 if (lrsym->isspilt || !lrsym->nRegs ||
444 (lrsym->liveTo < forSym->liveFrom))
447 /* go thru the registers : if it is either
448 r0 or r1 then spil it */
449 for (j = 0; j < lrsym->nRegs; j++)
450 if (lrsym->regs[j] == r0 ||
451 lrsym->regs[j] == r1)
460 /*-----------------------------------------------------------------*/
461 /* createStackSpil - create a location on the stack to spil */
462 /*-----------------------------------------------------------------*/
464 createStackSpil (symbol * sym)
467 int useXstack, model, noOverlay;
471 /* first go try and find a free one that is already
472 existing on the stack */
473 if (applyToSet (_G.stackSpil, isFree, &sloc, sym))
475 /* found a free one : just update & return */
476 sym->usl.spillLoc = sloc;
479 addSetHead (&sloc->usl.itmpStack, sym);
483 /* could not then have to create one , this is the hard part
484 we need to allocate this on the stack : this is really a
485 hack!! but cannot think of anything better at this time */
487 if (SNPRINTF (slocBuffer, sizeof(slocBuffer),
488 "sloc%d", _G.slocNum++) >= sizeof (slocBuffer))
490 fprintf (stderr, "***Internal error: slocBuffer overflowed: %s:%d\n",
495 sloc = newiTemp (slocBuffer);
497 /* set the type to the spilling symbol */
498 sloc->type = copyLinkChain (sym->type);
499 sloc->etype = getSpec (sloc->type);
500 if (options.model == MODEL_SMALL) {
501 SPEC_SCLS (sloc->etype) = S_DATA;
503 SPEC_SCLS (sloc->etype) = S_XDATA;
505 SPEC_EXTR (sloc->etype) = 0;
506 SPEC_STAT (sloc->etype) = 0;
507 SPEC_VOLATILE(sloc->etype) = 0;
508 SPEC_ABSA(sloc->etype) = 0;
510 /* we don't allow it to be allocated`
511 onto the external stack since : so we
512 temporarily turn it off ; we also
513 turn off memory model to prevent
514 the spil from going to the external storage
515 and turn off overlaying
518 useXstack = options.useXstack;
519 model = options.model;
520 noOverlay = options.noOverlay;
521 options.noOverlay = 1;
523 /* options.model = options.useXstack = 0; */
527 options.useXstack = useXstack;
528 options.model = model;
529 options.noOverlay = noOverlay;
530 sloc->isref = 1; /* to prevent compiler warning */
532 /* if it is on the stack then update the stack */
533 if (IN_STACK (sloc->etype))
535 currFunc->stack += getSize (sloc->type);
536 _G.stackExtend += getSize (sloc->type);
539 _G.dataExtend += getSize (sloc->type);
541 /* add it to the _G.stackSpil set */
542 addSetHead (&_G.stackSpil, sloc);
543 sym->usl.spillLoc = sloc;
546 /* add it to the set of itempStack set
547 of the spill location */
548 addSetHead (&sloc->usl.itmpStack, sym);
552 /*-----------------------------------------------------------------*/
553 /* isSpiltOnStack - returns true if the spil location is on stack */
554 /*-----------------------------------------------------------------*/
556 isSpiltOnStack (symbol * sym)
566 /* if (sym->_G.stackSpil) */
569 if (!sym->usl.spillLoc)
572 etype = getSpec (sym->usl.spillLoc->type);
573 if (IN_STACK (etype))
579 /*-----------------------------------------------------------------*/
580 /* spillThis - spils a specific operand */
581 /*-----------------------------------------------------------------*/
583 spillThis (symbol * sym)
586 /* if this is rematerializable or has a spillLocation
587 we are okay, else we need to create a spillLocation
589 if (!(sym->remat || sym->usl.spillLoc))
590 createStackSpil (sym);
593 /* mark it has spilt & put it in the spilt set */
594 sym->isspilt = sym->spillA = 1;
595 _G.spiltSet = bitVectSetBit (_G.spiltSet, sym->key);
597 bitVectUnSetBit (_G.regAssigned, sym->key);
598 bitVectUnSetBit (_G.totRegAssigned, sym->key);
600 for (i = 0; i < sym->nRegs; i++)
604 freeReg (sym->regs[i]);
608 /* if spilt on stack then free up r0 & r1
609 if they could have been assigned to some
611 if (!ds390_ptrRegReq && isSpiltOnStack (sym) && !options.stack10bit)
614 spillLRWithPtrReg (sym);
617 if (sym->usl.spillLoc && !sym->remat)
618 sym->usl.spillLoc->allocreq++;
622 /*-----------------------------------------------------------------*/
623 /* selectSpil - select a iTemp to spil : rather a simple procedure */
624 /*-----------------------------------------------------------------*/
626 selectSpil (iCode * ic, eBBlock * ebp, symbol * forSym)
628 bitVect *lrcs = NULL;
632 /* get the spillable live ranges */
633 lrcs = computeSpillable (ic);
635 /* get all live ranges that are rematerizable */
636 if ((selectS = liveRangesWith (lrcs, rematable, ebp, ic)))
639 /* return the least used of these */
640 return leastUsedLR (selectS);
643 /* get live ranges with spillLocations in direct space */
644 if ((selectS = liveRangesWith (lrcs, directSpilLoc, ebp, ic)))
646 sym = leastUsedLR (selectS);
647 strncpyz (sym->rname,
648 sym->usl.spillLoc->rname[0] ?
649 sym->usl.spillLoc->rname : sym->usl.spillLoc->name,
652 /* mark it as allocation required */
653 sym->usl.spillLoc->allocreq++;
657 /* if the symbol is local to the block then */
658 if (forSym->liveTo < ebp->lSeq)
661 /* check if there are any live ranges allocated
662 to registers that are not used in this block */
663 if (!_G.blockSpil && (selectS = liveRangesWith (lrcs, notUsedInBlock, ebp, ic)))
665 sym = leastUsedLR (selectS);
666 /* if this is not rematerializable */
675 /* check if there are any live ranges that not
676 used in the remainder of the block */
677 if (!_G.blockSpil && (selectS = liveRangesWith (lrcs, notUsedInRemaining, ebp, ic)))
679 sym = leastUsedLR (selectS);
692 /* find live ranges with spillocation && not used as pointers */
693 if ((selectS = liveRangesWith (lrcs, hasSpilLocnoUptr, ebp, ic)))
696 sym = leastUsedLR (selectS);
697 /* mark this as allocation required */
698 sym->usl.spillLoc->allocreq++;
702 /* find live ranges with spillocation */
703 if ((selectS = liveRangesWith (lrcs, hasSpilLoc, ebp, ic)))
706 sym = leastUsedLR (selectS);
707 sym->usl.spillLoc->allocreq++;
711 /* couldn't find then we need to create a spil
712 location on the stack , for which one? the least
714 if ((selectS = liveRangesWith (lrcs, noSpilLoc, ebp, ic)))
717 /* return a created spil location */
718 sym = createStackSpil (leastUsedLR (selectS));
719 sym->usl.spillLoc->allocreq++;
723 /* this is an extreme situation we will spill
724 this one : happens very rarely but it does happen */
730 /*-----------------------------------------------------------------*/
731 /* spilSomething - spil some variable & mark registers as free */
732 /*-----------------------------------------------------------------*/
734 spilSomething (iCode * ic, eBBlock * ebp, symbol * forSym)
739 /* get something we can spil */
740 ssym = selectSpil (ic, ebp, forSym);
742 /* mark it as spilt */
743 ssym->isspilt = ssym->spillA = 1;
744 _G.spiltSet = bitVectSetBit (_G.spiltSet, ssym->key);
746 /* mark it as not register assigned &
747 take it away from the set */
748 bitVectUnSetBit (_G.regAssigned, ssym->key);
749 bitVectUnSetBit (_G.totRegAssigned, ssym->key);
751 /* mark the registers as free */
752 for (i = 0; i < ssym->nRegs; i++)
754 freeReg (ssym->regs[i]);
756 /* if spilt on stack then free up r0 & r1
757 if they could have been assigned to as gprs */
758 if (!ds390_ptrRegReq && isSpiltOnStack (ssym) && !options.stack10bit)
761 spillLRWithPtrReg (ssym);
764 /* if this was a block level spil then insert push & pop
765 at the start & end of block respectively */
768 iCode *nic = newiCode (IPUSH, operandFromSymbol (ssym), NULL);
769 /* add push to the start of the block */
770 addiCodeToeBBlock (ebp, nic, (ebp->sch->op == LABEL ?
771 ebp->sch->next : ebp->sch));
772 nic = newiCode (IPOP, operandFromSymbol (ssym), NULL);
773 /* add pop to the end of the block */
774 addiCodeToeBBlock (ebp, nic, NULL);
777 /* if spilt because not used in the remainder of the
778 block then add a push before this instruction and
779 a pop at the end of the block */
780 if (ssym->remainSpil)
783 iCode *nic = newiCode (IPUSH, operandFromSymbol (ssym), NULL);
784 /* add push just before this instruction */
785 addiCodeToeBBlock (ebp, nic, ic);
787 nic = newiCode (IPOP, operandFromSymbol (ssym), NULL);
788 /* add pop to the end of the block */
789 addiCodeToeBBlock (ebp, nic, NULL);
798 /*-----------------------------------------------------------------*/
799 /* getRegPtr - will try for PTR if not a GPR type if not spil */
800 /*-----------------------------------------------------------------*/
802 getRegPtr (iCode * ic, eBBlock * ebp, symbol * sym)
807 /* try for a ptr type */
808 if ((reg = allocReg (REG_PTR)))
811 /* try for gpr type */
812 if ((reg = allocReg (REG_GPR)))
815 /* we have to spil */
816 if (!spilSomething (ic, ebp, sym))
819 /* this looks like an infinite loop but
820 in really selectSpil will abort */
824 /*-----------------------------------------------------------------*/
825 /* getRegGpr - will try for GPR if not spil */
826 /*-----------------------------------------------------------------*/
828 getRegGpr (iCode * ic, eBBlock * ebp, symbol * sym)
833 /* try for gpr type */
834 if ((reg = allocReg (REG_GPR)))
837 if (!ds390_ptrRegReq)
838 if ((reg = allocReg (REG_PTR)))
841 /* we have to spil */
842 if (!spilSomething (ic, ebp, sym))
845 /* this looks like an infinite loop but
846 in really selectSpil will abort */
850 /*-----------------------------------------------------------------*/
851 /* getRegPtrNoSpil - get it cannot split */
852 /*-----------------------------------------------------------------*/
853 static regs *getRegPtrNoSpil()
857 /* try for a ptr type */
858 if ((reg = allocReg (REG_PTR)))
861 /* try for gpr type */
862 if ((reg = allocReg (REG_GPR)))
867 /* just to make the compiler happy */
871 /*-----------------------------------------------------------------*/
872 /* getRegGprNoSpil - get it cannot split */
873 /*-----------------------------------------------------------------*/
874 static regs *getRegGprNoSpil()
878 if ((reg = allocReg (REG_GPR)))
881 if (!ds390_ptrRegReq)
882 if ((reg = allocReg (REG_PTR)))
887 /* just to make the compiler happy */
891 /*-----------------------------------------------------------------*/
892 /* symHasReg - symbol has a given register */
893 /*-----------------------------------------------------------------*/
895 symHasReg (symbol * sym, regs * reg)
899 for (i = 0; i < sym->nRegs; i++)
900 if (sym->regs[i] == reg)
906 /*-----------------------------------------------------------------*/
907 /* deassignLRs - check the live to and if they have registers & are */
908 /* not spilt then free up the registers */
909 /*-----------------------------------------------------------------*/
911 deassignLRs (iCode * ic, eBBlock * ebp)
917 for (sym = hTabFirstItem (liveRanges, &k); sym;
918 sym = hTabNextItem (liveRanges, &k))
922 /* if it does not end here */
923 if (sym->liveTo > ic->seq)
926 /* if it was spilt on stack then we can
927 mark the stack spil location as free */
932 sym->usl.spillLoc->isFree = 1;
938 if (!bitVectBitValue (_G.regAssigned, sym->key))
941 /* special case check if this is an IFX &
942 the privious one was a pop and the
943 previous one was not spilt then keep track
945 if (ic->op == IFX && ic->prev &&
946 ic->prev->op == IPOP &&
947 !ic->prev->parmPush &&
948 !OP_SYMBOL (IC_LEFT (ic->prev))->isspilt)
949 psym = OP_SYMBOL (IC_LEFT (ic->prev));
955 bitVectUnSetBit (_G.regAssigned, sym->key);
957 /* if the result of this one needs registers
958 and does not have it then assign it right
960 if (IC_RESULT (ic) &&
961 !(SKIP_IC2 (ic) || /* not a special icode */
962 ic->op == JUMPTABLE ||
968 (result = OP_SYMBOL (IC_RESULT (ic))) && /* has a result */
969 result->liveTo > ic->seq && /* and will live beyond this */
970 result->liveTo <= ebp->lSeq && /* does not go beyond this block */
971 result->regType == sym->regType && /* same register types */
972 result->nRegs && /* which needs registers */
973 !result->isspilt && /* and does not already have them */
975 !bitVectBitValue (_G.regAssigned, result->key) &&
976 /* the number of free regs + number of regs in this LR
977 can accomodate the what result Needs */
978 ((nfreeRegsType (result->regType) +
979 sym->nRegs) >= result->nRegs)
983 for (i = 0; i < result->nRegs; i++)
985 result->regs[i] = sym->regs[i];
987 result->regs[i] = getRegGpr (ic, ebp, result);
989 _G.regAssigned = bitVectSetBit (_G.regAssigned, result->key);
990 _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, result->key);
994 /* free the remaining */
995 for (; i < sym->nRegs; i++)
999 if (!symHasReg (psym, sym->regs[i]))
1000 freeReg (sym->regs[i]);
1003 freeReg (sym->regs[i]);
1010 /*-----------------------------------------------------------------*/
1011 /* reassignLR - reassign this to registers */
1012 /*-----------------------------------------------------------------*/
1014 reassignLR (operand * op)
1016 symbol *sym = OP_SYMBOL (op);
1019 /* not spilt any more */
1020 sym->isspilt = sym->spillA = sym->blockSpil = sym->remainSpil = 0;
1021 bitVectUnSetBit (_G.spiltSet, sym->key);
1023 _G.regAssigned = bitVectSetBit (_G.regAssigned, sym->key);
1024 _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, sym->key);
1028 for (i = 0; i < sym->nRegs; i++)
1029 sym->regs[i]->isFree = 0;
1032 /*-----------------------------------------------------------------*/
1033 /* willCauseSpill - determines if allocating will cause a spill */
1034 /*-----------------------------------------------------------------*/
1036 willCauseSpill (int nr, int rt)
1038 /* first check if there are any avlb registers
1039 of te type required */
1042 /* special case for pointer type
1043 if pointer type not avlb then
1044 check for type gpr */
1045 if (nFreeRegs (rt) >= nr)
1047 if (nFreeRegs (REG_GPR) >= nr)
1052 if (ds390_ptrRegReq)
1054 if (nFreeRegs (rt) >= nr)
1059 if (nFreeRegs (REG_PTR) +
1060 nFreeRegs (REG_GPR) >= nr)
1065 /* it will cause a spil */
1069 /*-----------------------------------------------------------------*/
1070 /* positionRegs - the allocator can allocate same registers to res- */
1071 /* ult and operand, if this happens make sure they are in the same */
1072 /* position as the operand otherwise chaos results */
1073 /*-----------------------------------------------------------------*/
1075 positionRegs (symbol * result, symbol * opsym)
1077 int count = min (result->nRegs, opsym->nRegs);
1078 int i, j = 0, shared = 0;
1081 /* if the result has been spilt then cannot share */
1086 /* first make sure that they actually share */
1087 for (i = 0; i < count; i++)
1089 for (j = 0; j < count; j++)
1091 if (result->regs[i] == opsym->regs[j] && i != j)
1101 regs *tmp = result->regs[i];
1102 result->regs[i] = result->regs[j];
1103 result->regs[j] = tmp;
1110 /*-----------------------------------------------------------------*/
1111 /* unusedLRS - returns a bitVector of liveranges not used in 'ebp' */
1112 /*-----------------------------------------------------------------*/
1113 bitVect *unusedLRs (eBBlock *ebp)
1115 bitVect *ret = NULL;
1119 if (!ebp) return NULL;
1120 for (sym = hTabFirstItem(liveRanges,&key); sym ;
1121 sym = hTabNextItem(liveRanges,&key)) {
1123 if (notUsedInBlock(sym,ebp,NULL)) {
1124 ret = bitVectSetBit(ret,sym->key);
1131 /*-----------------------------------------------------------------*/
1132 /* deassignUnsedLRs - if this baisc block ends in a return then */
1133 /* deassign symbols not used in this block */
1134 /*-----------------------------------------------------------------*/
1135 bitVect *deassignUnsedLRs(eBBlock *ebp)
1137 bitVect *unused = NULL;
1140 switch (returnAtEnd(ebp)) {
1141 case 2: /* successor block ends in a return */
1142 unused = unusedLRs((eBBlock *) setFirstItem(ebp->succList));
1144 case 1: /* this block ends in a return */
1145 unused = bitVectIntersect(unused,unusedLRs(ebp));
1150 for (i = 0 ; i < unused->size ; i++ ) {
1153 if (bitVectBitValue(unused,i)) {
1155 /* if assigned to registers */
1156 if (bitVectBitValue(_G.regAssigned,i)) {
1160 sym = hTabItemWithKey(liveRanges,i);
1161 /* remove it from regassigned & mark the
1163 bitVectUnSetBit(_G.regAssigned,i);
1164 for (j = 0 ; j < sym->nRegs; j++)
1165 freeReg(sym->regs[j]);
1167 /* not assigned to registers : remove from set*/
1168 bitVectUnSetBit(unused,i);
1176 /*-----------------------------------------------------------------*/
1177 /* reassignUnusedLRs - put registers to unused Live ranges */
1178 /*-----------------------------------------------------------------*/
1179 void reassignUnusedLRs (bitVect *unused)
1182 if (!unused) return ;
1184 for (i = 0 ; i < unused->size ; i++ ) {
1185 /* if unused : means it was assigned to registers before */
1186 if (bitVectBitValue(unused,i)) {
1190 /* put it back into reg set*/
1191 bitVectSetBit(_G.regAssigned,i) ;
1193 sym = hTabItemWithKey(liveRanges,i);
1194 /* makr registers busy */
1195 for (j = 0 ; j < sym->nRegs; j++)
1196 sym->regs[j]->isFree = 0;
1201 /*-----------------------------------------------------------------*/
1202 /* serialRegAssign - serially allocate registers to the variables */
1203 /*-----------------------------------------------------------------*/
1205 serialRegAssign (eBBlock ** ebbs, int count)
1209 /* for all blocks */
1210 for (i = 0; i < count; i++)
1214 bitVect *unusedLRs = NULL;
1216 if (ebbs[i]->noPath &&
1217 (ebbs[i]->entryLabel != entryLabel &&
1218 ebbs[i]->entryLabel != returnLabel))
1221 unusedLRs = deassignUnsedLRs(ebbs[i]);
1223 /* of all instructions do */
1224 for (ic = ebbs[i]->sch; ic; ic = ic->next)
1227 /* if this is an ipop that means some live
1228 range will have to be assigned again */
1230 reassignLR (IC_LEFT (ic));
1232 /* if result is present && is a true symbol */
1233 if (IC_RESULT (ic) && ic->op != IFX &&
1234 IS_TRUE_SYMOP (IC_RESULT (ic)))
1235 OP_SYMBOL (IC_RESULT (ic))->allocreq++;
1237 /* take away registers from live
1238 ranges that end at this instruction */
1239 deassignLRs (ic, ebbs[i]);
1241 /* some don't need registers */
1242 if (SKIP_IC2 (ic) ||
1243 ic->op == JUMPTABLE ||
1247 (IC_RESULT (ic) && POINTER_SET (ic)))
1250 /* now we need to allocate registers
1251 only for the result */
1254 symbol *sym = OP_SYMBOL (IC_RESULT (ic));
1260 /* if it does not need or is spilt
1261 or is already assigned to registers
1262 or will not live beyond this instructions */
1265 bitVectBitValue (_G.regAssigned, sym->key) ||
1266 sym->liveTo <= ic->seq)
1269 /* if some liverange has been spilt at the block level
1270 and this one live beyond this block then spil this
1272 if (_G.blockSpil && sym->liveTo > ebbs[i]->lSeq)
1277 /* if trying to allocate this will cause
1278 a spill and there is nothing to spill
1279 or this one is rematerializable then
1281 willCS = willCauseSpill (sym->nRegs, sym->regType);
1282 spillable = computeSpillable (ic);
1284 (willCS && bitVectIsZero (spillable)))
1292 /* if it has a spillocation & is used less than
1293 all other live ranges then spill this */
1295 if (sym->usl.spillLoc) {
1296 symbol *leastUsed = leastUsedLR (liveRangesWith (spillable,
1297 allLRs, ebbs[i], ic));
1298 if (leastUsed && leastUsed->used > sym->used) {
1303 /* if none of the liveRanges have a spillLocation then better
1304 to spill this one than anything else already assigned to registers */
1305 if (liveRangesWith(spillable,noSpilLoc,ebbs[i],ic)) {
1306 /* if this is local to this block then we might find a block spil */
1307 if (!(sym->liveFrom >= ebbs[i]->fSeq && sym->liveTo <= ebbs[i]->lSeq)) {
1315 /* if we need ptr regs for the right side
1317 if (POINTER_GET (ic) && IS_SYMOP (IC_LEFT (ic))
1318 && getSize (OP_SYMBOL (IC_LEFT (ic))->type)
1319 <= (unsigned) PTRSIZE)
1324 /* else we assign registers to it */
1325 _G.regAssigned = bitVectSetBit (_G.regAssigned, sym->key);
1326 _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, sym->key);
1328 for (j = 0; j < sym->nRegs; j++)
1330 if (sym->regType == REG_PTR)
1331 sym->regs[j] = getRegPtr (ic, ebbs[i], sym);
1333 sym->regs[j] = getRegGpr (ic, ebbs[i], sym);
1335 /* if the allocation falied which means
1336 this was spilt then break */
1341 /* if it shares registers with operands make sure
1342 that they are in the same position */
1343 if (!POINTER_SET(ic) && !POINTER_GET(ic))
1345 if (IC_LEFT (ic) && IS_SYMOP (IC_LEFT (ic)) &&
1346 OP_SYMBOL (IC_LEFT (ic))->nRegs)
1348 positionRegs (OP_SYMBOL (IC_RESULT (ic)),
1349 OP_SYMBOL (IC_LEFT (ic)));
1351 /* do the same for the right operand */
1352 if (IC_RIGHT (ic) && IS_SYMOP (IC_RIGHT (ic)) &&
1353 OP_SYMBOL (IC_RIGHT (ic))->nRegs)
1355 positionRegs (OP_SYMBOL (IC_RESULT (ic)),
1356 OP_SYMBOL (IC_RIGHT (ic)));
1368 reassignUnusedLRs(unusedLRs);
1372 /*-----------------------------------------------------------------*/
1373 /* fillGaps - Try to fill in the Gaps left by Pass1 */
1374 /*-----------------------------------------------------------------*/
1375 static void fillGaps()
1379 int loop = 0, change;
1382 if (getenv("DISABLE_FILL_GAPS")) return;
1384 /* First try to do DPTRuse once more since now we know what got into
1387 while (loop++ < 10) {
1390 for (sym = hTabFirstItem(liveRanges,&key) ; sym ;
1391 sym = hTabNextItem(liveRanges,&key)) {
1392 int size = getSize(sym->type);
1394 if (sym->liveFrom == sym->liveTo) continue;
1396 if (sym->uptr && sym->dptr==0 && !sym->ruonly &&
1397 size < 4 && size > 1) {
1399 if (packRegsDPTRuse(operandFromSymbol(sym))) {
1401 /* if this was ssigned to registers then */
1402 if (bitVectBitValue(_G.totRegAssigned,sym->key)) {
1403 /* take it out of the register assigned set */
1404 bitVectUnSetBit(_G.totRegAssigned,sym->key);
1405 } else if (sym->usl.spillLoc) {
1406 sym->usl.spillLoc->allocreq--;
1407 sym->usl.spillLoc = NULL;
1411 sym->isspilt = sym->spillA = 0;
1415 /* try assigning other dptrs */
1416 if (sym->dptr == 0 && packRegsDPTRnuse(operandFromSymbol(sym),1) && !getenv("DPTRnDISABLE")) {
1417 /* if this was ssigned to registers then */
1418 if (bitVectBitValue(_G.totRegAssigned,sym->key)) {
1419 /* take it out of the register assigned set */
1420 bitVectUnSetBit(_G.totRegAssigned,sym->key);
1421 } else if (sym->usl.spillLoc) {
1422 sym->usl.spillLoc->allocreq--;
1423 sym->usl.spillLoc = NULL;
1426 sym->isspilt = sym->spillA = 0;
1431 /* look for livernages that was spilt by the allocator */
1432 for (sym = hTabFirstItem(liveRanges,&key) ; sym ;
1433 sym = hTabNextItem(liveRanges,&key)) {
1438 if (!sym->spillA || !sym->clashes || sym->remat) continue ;
1439 if (!sym->uses || !sym->defs) continue ;
1440 /* find the liveRanges this one clashes with, that are
1441 still assigned to registers & mark the registers as used*/
1442 for ( i = 0 ; i < sym->clashes->size ; i ++) {
1446 if (bitVectBitValue(sym->clashes,i) == 0 || /* those that clash with this */
1447 bitVectBitValue(_G.totRegAssigned,i) == 0) /* and are still assigned to registers */
1450 clr = hTabItemWithKey(liveRanges,i);
1453 /* mark these registers as used */
1454 for (k = 0 ; k < clr->nRegs ; k++ )
1455 useReg(clr->regs[k]);
1458 if (willCauseSpill(sym->nRegs,sym->regType)) {
1459 /* NOPE :( clear all registers & and continue */
1464 /* THERE IS HOPE !!!! */
1465 for (i=0; i < sym->nRegs ; i++ ) {
1466 if (sym->regType == REG_PTR)
1467 sym->regs[i] = getRegPtrNoSpil ();
1469 sym->regs[i] = getRegGprNoSpil ();
1472 /* For all its definitions check if the registers
1473 allocated needs positioning NOTE: we can position
1474 only ONCE if more than One positioning required
1476 We may need to perform the checks twice; once to
1477 position the registers as needed, the second to
1478 verify any register repositioning is still
1482 for (pass=0; pass<2; pass++) {
1483 for (i = 0 ; i < sym->defs->size ; i++ ) {
1484 if (bitVectBitValue(sym->defs,i)) {
1486 if (!(ic = hTabItemWithKey(iCodehTab,i))) continue ;
1487 if (SKIP_IC(ic)) continue;
1488 assert(isSymbolEqual(sym,OP_SYMBOL(IC_RESULT(ic)))); /* just making sure */
1489 /* if left is assigned to registers */
1490 if (IS_SYMOP(IC_LEFT(ic)) &&
1491 bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_LEFT(ic))->key)) {
1492 pdone += (positionRegs(sym,OP_SYMBOL(IC_LEFT(ic)))>0);
1494 if (IS_SYMOP(IC_RIGHT(ic)) &&
1495 bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_RIGHT(ic))->key)) {
1496 pdone += (positionRegs(sym,OP_SYMBOL(IC_RIGHT(ic)))>0);
1498 if (pdone > 1) break;
1501 for (i = 0 ; i < sym->uses->size ; i++ ) {
1502 if (bitVectBitValue(sym->uses,i)) {
1504 if (!(ic = hTabItemWithKey(iCodehTab,i))) continue ;
1505 if (SKIP_IC(ic)) continue;
1506 if (POINTER_SET(ic) || POINTER_GET(ic)) continue ;
1508 /* if result is assigned to registers */
1509 if (IS_SYMOP(IC_RESULT(ic)) &&
1510 bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_RESULT(ic))->key)) {
1511 pdone += (positionRegs(sym,OP_SYMBOL(IC_RESULT(ic)))>0);
1513 if (pdone > 1) break;
1516 if (pdone == 0) break; /* second pass only if regs repositioned */
1517 if (pdone > 1) break;
1519 /* had to position more than once GIVE UP */
1521 /* UNDO all the changes we made to try this */
1523 for (i=0; i < sym->nRegs ; i++ ) {
1524 sym->regs[i] = NULL;
1527 D (fprintf (stderr, "Fill Gap gave up due to positioning for "
1528 "%s in function %s\n",
1529 sym->name, currFunc ? currFunc->name : "UNKNOWN"));
1532 D (fprintf (stderr, "FILLED GAP for %s in function %s\n",
1533 sym->name, currFunc ? currFunc->name : "UNKNOWN"));
1534 _G.totRegAssigned = bitVectSetBit(_G.totRegAssigned,sym->key);
1535 sym->isspilt = sym->spillA = 0 ;
1536 sym->usl.spillLoc->allocreq--;
1537 sym->usl.spillLoc = NULL;
1545 /*-----------------------------------------------------------------*/
1546 /* rUmaskForOp :- returns register mask for an operand */
1547 /*-----------------------------------------------------------------*/
1549 ds390_rUmaskForOp (operand * op)
1555 /* only temporaries are assigned registers */
1559 sym = OP_SYMBOL (op);
1561 /* if spilt or no registers assigned to it
1563 if (sym->isspilt || !sym->nRegs)
1566 rumask = newBitVect (ds390_nRegs);
1568 for (j = 0; j < sym->nRegs; j++)
1570 rumask = bitVectSetBit (rumask,
1571 sym->regs[j]->rIdx);
1577 /*-----------------------------------------------------------------*/
1578 /* regsUsedIniCode :- returns bit vector of registers used in iCode */
1579 /*-----------------------------------------------------------------*/
1581 regsUsedIniCode (iCode * ic)
1583 bitVect *rmask = newBitVect (ds390_nRegs);
1585 /* do the special cases first */
1588 rmask = bitVectUnion (rmask,
1589 ds390_rUmaskForOp (IC_COND (ic)));
1593 /* for the jumptable */
1594 if (ic->op == JUMPTABLE)
1596 rmask = bitVectUnion (rmask,
1597 ds390_rUmaskForOp (IC_JTCOND (ic)));
1602 /* of all other cases */
1604 rmask = bitVectUnion (rmask,
1605 ds390_rUmaskForOp (IC_LEFT (ic)));
1609 rmask = bitVectUnion (rmask,
1610 ds390_rUmaskForOp (IC_RIGHT (ic)));
1613 rmask = bitVectUnion (rmask,
1614 ds390_rUmaskForOp (IC_RESULT (ic)));
1620 /*-----------------------------------------------------------------*/
1621 /* createRegMask - for each instruction will determine the regsUsed */
1622 /*-----------------------------------------------------------------*/
1624 createRegMask (eBBlock ** ebbs, int count)
1628 /* for all blocks */
1629 for (i = 0; i < count; i++)
1633 if (ebbs[i]->noPath &&
1634 (ebbs[i]->entryLabel != entryLabel &&
1635 ebbs[i]->entryLabel != returnLabel))
1638 /* for all instructions */
1639 for (ic = ebbs[i]->sch; ic; ic = ic->next)
1644 if (SKIP_IC2 (ic) || !ic->rlive)
1647 /* first mark the registers used in this
1649 ic->rUsed = regsUsedIniCode (ic);
1650 _G.funcrUsed = bitVectUnion (_G.funcrUsed, ic->rUsed);
1652 /* now create the register mask for those
1653 registers that are in use : this is a
1654 super set of ic->rUsed */
1655 ic->rMask = newBitVect (ds390_nRegs + 1);
1657 /* for all live Ranges alive at this point */
1658 for (j = 1; j < ic->rlive->size; j++)
1663 /* if not alive then continue */
1664 if (!bitVectBitValue (ic->rlive, j))
1667 /* find the live range we are interested in */
1668 if (!(sym = hTabItemWithKey (liveRanges, j)))
1670 werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
1671 "createRegMask cannot find live range");
1675 /* special case for ruonly */
1676 if (sym->ruonly && sym->liveFrom != sym->liveTo) {
1677 int size = getSize(sym->type);
1679 for (k = 0 ; k < size; k++ )
1680 ic->rMask = bitVectSetBit (ic->rMask, j++);
1684 /* if no register assigned to it */
1685 if (!sym->nRegs || sym->isspilt)
1688 /* for all the registers allocated to it */
1689 for (k = 0; k < sym->nRegs; k++)
1692 bitVectSetBit (ic->rMask, sym->regs[k]->rIdx);
1698 /*-----------------------------------------------------------------*/
1699 /* rematStr - returns the rematerialized string for a remat var */
1700 /*-----------------------------------------------------------------*/
1702 rematStr (symbol * sym)
1705 iCode *ic = sym->rematiCode;
1712 /* if plus or minus print the right hand side */
1713 if (ic->op == '+' || ic->op == '-')
1715 SNPRINTF (s, sizeof(buffer) - strlen(buffer),
1716 "0x%04x %c ", (int) operandLitValue (IC_RIGHT (ic)),
1719 ic = OP_SYMBOL (IC_LEFT (ic))->rematiCode;
1722 /* cast then continue */
1723 if (IS_CAST_ICODE(ic)) {
1724 ic = OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
1727 /* we reached the end */
1728 SNPRINTF (s, sizeof(buffer) - strlen(buffer),
1729 "%s", OP_SYMBOL (IC_LEFT (ic))->rname);
1736 /*-----------------------------------------------------------------*/
1737 /* regTypeNum - computes the type & number of registers required */
1738 /*-----------------------------------------------------------------*/
1746 /* for each live range do */
1747 for (sym = hTabFirstItem (liveRanges, &k); sym;
1748 sym = hTabNextItem (liveRanges, &k))
1751 /* if used zero times then no registers needed */
1752 if ((sym->liveTo - sym->liveFrom) == 0)
1756 /* if the live range is a temporary */
1760 /* if the type is marked as a conditional */
1761 if (sym->regType == REG_CND)
1764 /* if used in return only then we don't
1766 if (sym->ruonly || sym->accuse)
1768 if (IS_AGGREGATE (sym->type) || sym->isptr)
1769 sym->type = aggrToPtr (sym->type, FALSE);
1773 /* if the symbol has only one definition &
1774 that definition is a get_pointer */
1775 if (bitVectnBitsOn (sym->defs) == 1 &&
1776 (ic = hTabItemWithKey (iCodehTab,
1777 bitVectFirstBit (sym->defs))) &&
1780 !IS_BITVAR (sym->etype))
1782 /* and that pointer is remat in data space */
1783 if (IS_SYMOP (IC_LEFT (ic)) &&
1784 OP_SYMBOL (IC_LEFT (ic))->remat &&
1785 !IS_CAST_ICODE(OP_SYMBOL (IC_LEFT (ic))->rematiCode) &&
1786 DCL_TYPE (aggrToPtr (operandType(IC_LEFT(ic)), FALSE)) == POINTER)
1789 /* create a psuedo symbol & force a spil */
1790 symbol *psym = newSymbol (rematStr (OP_SYMBOL (IC_LEFT (ic))), 1);
1791 psym->type = sym->type;
1792 psym->etype = sym->etype;
1793 strncpyz (psym->rname, psym->name, sizeof(psym->rname));
1795 sym->usl.spillLoc = psym;
1799 /* if in data space or idata space then try to
1800 allocate pointer register */
1804 /* if not then we require registers */
1805 sym->nRegs = ((IS_AGGREGATE (sym->type) || sym->isptr) ?
1806 getSize (sym->type = aggrToPtr (sym->type, FALSE)) :
1807 getSize (sym->type));
1811 fprintf (stderr, "allocated more than 4 or 0 registers for type ");
1812 printTypeChain (sym->type, stderr);
1813 fprintf (stderr, "\n");
1816 /* determine the type of register required */
1817 if (sym->nRegs == 1 &&
1818 IS_PTR (sym->type) &&
1820 sym->regType = REG_PTR;
1822 sym->regType = REG_GPR;
1826 /* for the first run we don't provide */
1827 /* registers for true symbols we will */
1828 /* see how things go */
1834 /*-----------------------------------------------------------------*/
1835 /* freeAllRegs - mark all registers as free */
1836 /*-----------------------------------------------------------------*/
1842 for (i = 0; i < ds390_nRegs; i++)
1843 regs390[i].isFree = 1;
1846 /*-----------------------------------------------------------------*/
1847 /* deallocStackSpil - this will set the stack pointer back */
1848 /*-----------------------------------------------------------------*/
1850 DEFSETFUNC (deallocStackSpil)
1858 /*-----------------------------------------------------------------*/
1859 /* farSpacePackable - returns the packable icode for far variables */
1860 /*-----------------------------------------------------------------*/
1862 farSpacePackable (iCode * ic)
1866 /* go thru till we find a definition for the
1867 symbol on the right */
1868 for (dic = ic->prev; dic; dic = dic->prev)
1871 /* if the definition is a call then no */
1872 if ((dic->op == CALL || dic->op == PCALL) &&
1873 IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
1878 /* if shift by unknown amount then not */
1879 if ((dic->op == LEFT_OP || dic->op == RIGHT_OP) &&
1880 IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
1883 /* if pointer get and size > 1 */
1884 if (POINTER_GET (dic) &&
1885 getSize (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)) > 1)
1888 if (POINTER_SET (dic) &&
1889 getSize (aggrToPtr (operandType (IC_RESULT (dic)), FALSE)) > 1)
1892 /* if any three is a true symbol in far space */
1893 if (IC_RESULT (dic) &&
1894 IS_TRUE_SYMOP (IC_RESULT (dic)) &&
1895 isOperandInFarSpace (IC_RESULT (dic)))
1898 if (IC_RIGHT (dic) &&
1899 IS_TRUE_SYMOP (IC_RIGHT (dic)) &&
1900 isOperandInFarSpace (IC_RIGHT (dic)) &&
1901 !isOperandEqual (IC_RIGHT (dic), IC_RESULT (ic)))
1904 if (IC_LEFT (dic) &&
1905 IS_TRUE_SYMOP (IC_LEFT (dic)) &&
1906 isOperandInFarSpace (IC_LEFT (dic)) &&
1907 !isOperandEqual (IC_LEFT (dic), IC_RESULT (ic)))
1910 if (isOperandEqual (IC_RIGHT (ic), IC_RESULT (dic)))
1912 if ((dic->op == LEFT_OP ||
1913 dic->op == RIGHT_OP ||
1915 IS_OP_LITERAL (IC_RIGHT (dic)))
1925 /*-----------------------------------------------------------------*/
1926 /* packRegsForAssign - register reduction for assignment */
1927 /*-----------------------------------------------------------------*/
1929 packRegsForAssign (iCode * ic, eBBlock * ebp)
1933 if (!IS_ITEMP (IC_RIGHT (ic)) ||
1934 OP_SYMBOL (IC_RIGHT (ic))->isind ||
1935 OP_LIVETO (IC_RIGHT (ic)) > ic->seq)
1940 /* if the true symbol is defined in far space or on stack
1941 then we should not since this will increase register pressure */
1943 if (isOperandInFarSpace (IC_RESULT (ic)))
1945 if ((dic = farSpacePackable (ic)))
1951 if (isOperandInFarSpace(IC_RESULT(ic)) && !farSpacePackable(ic)) {
1956 /* find the definition of iTempNN scanning backwards if we find a
1957 a use of the true symbol in before we find the definition then
1959 for (dic = ic->prev; dic; dic = dic->prev)
1961 /* if there is a function call then don't pack it */
1962 if ((dic->op == CALL || dic->op == PCALL))
1971 if (IS_TRUE_SYMOP (IC_RESULT (dic)) &&
1972 IS_OP_VOLATILE (IC_RESULT (dic)))
1978 if (IS_SYMOP (IC_RESULT (dic)) &&
1979 IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
1981 if (POINTER_SET (dic))
1987 if (IS_SYMOP (IC_RIGHT (dic)) &&
1988 (IC_RIGHT (dic)->key == IC_RESULT (ic)->key ||
1989 IC_RIGHT (dic)->key == IC_RIGHT (ic)->key))
1995 if (IS_SYMOP (IC_LEFT (dic)) &&
1996 (IC_LEFT (dic)->key == IC_RESULT (ic)->key ||
1997 IC_LEFT (dic)->key == IC_RIGHT (ic)->key))
2003 if (POINTER_SET (dic) &&
2004 IC_RESULT (dic)->key == IC_RESULT (ic)->key)
2012 return 0; /* did not find */
2014 /* if the result is on stack or iaccess then it must be
2015 the same atleast one of the operands */
2016 if (OP_SYMBOL (IC_RESULT (ic))->onStack ||
2017 OP_SYMBOL (IC_RESULT (ic))->iaccess)
2020 /* the operation has only one symbol
2021 operator then we can pack */
2022 if ((IC_LEFT (dic) && !IS_SYMOP (IC_LEFT (dic))) ||
2023 (IC_RIGHT (dic) && !IS_SYMOP (IC_RIGHT (dic))))
2026 if (!((IC_LEFT (dic) &&
2027 IC_RESULT (ic)->key == IC_LEFT (dic)->key) ||
2029 IC_RESULT (ic)->key == IC_RIGHT (dic)->key)))
2033 /* found the definition */
2034 /* replace the result with the result of */
2035 /* this assignment and remove this assignment */
2036 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2038 IC_RESULT (dic) = IC_RESULT (ic);
2040 if (IS_ITEMP (IC_RESULT (dic)) && OP_SYMBOL (IC_RESULT (dic))->liveFrom > dic->seq)
2042 OP_SYMBOL (IC_RESULT (dic))->liveFrom = dic->seq;
2044 /* delete from liverange table also
2045 delete from all the points inbetween and the new
2047 for (sic = dic; sic != ic; sic = sic->next)
2049 bitVectUnSetBit (sic->rlive, IC_RESULT (ic)->key);
2050 if (IS_ITEMP (IC_RESULT (dic)))
2051 bitVectSetBit (sic->rlive, IC_RESULT (dic)->key);
2054 remiCodeFromeBBlock (ebp, ic);
2055 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
2056 hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
2057 OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
2062 /*-----------------------------------------------------------------*/
2063 /* findAssignToSym : scanning backwards looks for first assig found */
2064 /*-----------------------------------------------------------------*/
2066 findAssignToSym (operand * op, iCode * ic)
2070 for (dic = ic->prev; dic; dic = dic->prev)
2073 /* if definition by assignment */
2074 if (dic->op == '=' &&
2075 !POINTER_SET (dic) &&
2076 IC_RESULT (dic)->key == op->key
2077 /* && IS_TRUE_SYMOP(IC_RIGHT(dic)) */
2081 /* we are interested only if defined in far space */
2082 /* or in stack space in case of + & - */
2084 /* if assigned to a non-symbol then return
2086 if (!IS_SYMOP (IC_RIGHT (dic)))
2089 /* if the symbol is in far space then
2091 if (isOperandInFarSpace (IC_RIGHT (dic)))
2094 /* for + & - operations make sure that
2095 if it is on the stack it is the same
2096 as one of the three operands */
2097 if ((ic->op == '+' || ic->op == '-') &&
2098 OP_SYMBOL (IC_RIGHT (dic))->onStack)
2101 if (IC_RESULT (ic)->key != IC_RIGHT (dic)->key &&
2102 IC_LEFT (ic)->key != IC_RIGHT (dic)->key &&
2103 IC_RIGHT (ic)->key != IC_RIGHT (dic)->key)
2111 /* if we find an usage then we cannot delete it */
2112 if (IC_LEFT (dic) && IC_LEFT (dic)->key == op->key)
2115 if (IC_RIGHT (dic) && IC_RIGHT (dic)->key == op->key)
2118 if (POINTER_SET (dic) && IC_RESULT (dic)->key == op->key)
2122 /* now make sure that the right side of dic
2123 is not defined between ic & dic */
2126 iCode *sic = dic->next;
2128 for (; sic != ic; sic = sic->next)
2129 if (IC_RESULT (sic) &&
2130 IC_RESULT (sic)->key == IC_RIGHT (dic)->key)
2139 /*-----------------------------------------------------------------*/
2140 /* packRegsForSupport :- reduce some registers for support calls */
2141 /*-----------------------------------------------------------------*/
2143 packRegsForSupport (iCode * ic, eBBlock * ebp)
2147 /* for the left & right operand :- look to see if the
2148 left was assigned a true symbol in far space in that
2149 case replace them */
2150 if (IS_ITEMP (IC_LEFT (ic)) &&
2151 OP_SYMBOL (IC_LEFT (ic))->liveTo <= ic->seq)
2153 iCode *dic = findAssignToSym (IC_LEFT (ic), ic);
2159 /* found it we need to remove it from the
2161 for (sic = dic; sic != ic; sic = sic->next) {
2162 bitVectUnSetBit (sic->rlive, IC_LEFT (ic)->key);
2163 sic->rlive = bitVectSetBit (sic->rlive, IC_RIGHT (dic)->key);
2166 wassert(IS_SYMOP(IC_LEFT (ic)));
2167 wassert(IS_SYMOP(IC_RIGHT (dic)));
2168 IC_LEFT (ic)->operand.symOperand =
2169 IC_RIGHT (dic)->operand.symOperand;
2170 OP_SYMBOL(IC_LEFT(ic))->liveTo = ic->seq;
2171 IC_LEFT (ic)->key = IC_RIGHT (dic)->operand.symOperand->key;
2172 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2173 remiCodeFromeBBlock (ebp, dic);
2174 hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2178 /* do the same for the right operand */
2181 IS_ITEMP (IC_RIGHT (ic)) &&
2182 OP_SYMBOL (IC_RIGHT (ic))->liveTo <= ic->seq)
2184 iCode *dic = findAssignToSym (IC_RIGHT (ic), ic);
2190 /* if this is a subtraction & the result
2191 is a true symbol in far space then don't pack */
2192 if (ic->op == '-' && IS_TRUE_SYMOP (IC_RESULT (dic)))
2194 sym_link *etype = getSpec (operandType (IC_RESULT (dic)));
2195 if (IN_FARSPACE (SPEC_OCLS (etype)))
2198 /* found it we need to remove it from the
2200 for (sic = dic; sic != ic; sic = sic->next) {
2201 bitVectUnSetBit (sic->rlive, IC_RIGHT (ic)->key);
2202 sic->rlive = bitVectSetBit (sic->rlive, IC_RIGHT (dic)->key);
2205 wassert(IS_SYMOP(IC_RIGHT (ic)));
2206 wassert(IS_SYMOP(IC_RIGHT (dic)));
2207 IC_RIGHT (ic)->operand.symOperand =
2208 IC_RIGHT (dic)->operand.symOperand;
2209 IC_RIGHT (ic)->key = IC_RIGHT (dic)->operand.symOperand->key;
2210 OP_SYMBOL(IC_RIGHT(ic))->liveTo = ic->seq;
2211 remiCodeFromeBBlock (ebp, dic);
2212 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2213 hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2220 #define IS_OP_RUONLY(x) (x && IS_SYMOP(x) && OP_SYMBOL(x)->ruonly)
2223 /*-----------------------------------------------------------------*/
2224 /* packRegsDPTRnuse - color live ranges that can go into extra DPTRS */
2225 /*-----------------------------------------------------------------*/
2226 static int packRegsDPTRnuse( operand *op , int dptr)
2231 if (!IS_SYMOP(op) || !IS_ITEMP(op)) return 0;
2232 if (OP_SYMBOL(op)->remat || OP_SYMBOL(op)->ruonly || OP_SYMBOL(op)->dptr)
2235 /* first check if any overlapping liverange has already been
2236 assigned to this DPTR */
2237 if (OP_SYMBOL(op)->clashes) {
2238 for (i = 0 ; i < OP_SYMBOL(op)->clashes->size ; i++ ) {
2240 if (bitVectBitValue(OP_SYMBOL(op)->clashes,i)) {
2241 sym = hTabItemWithKey(liveRanges,i);
2242 if (sym->dptr == dptr) return 0;
2247 /* future for more dptrs */
2249 OP_SYMBOL(op)->dptr = dptr;
2253 /* DPTR1 is special since it is also used as a scratch by the backend .
2254 so we walk thru the entire live range of this operand and make sure
2255 DPTR1 will not be used by the backed . The logic here is to find out if
2256 more than one operand in an icode is in far space then we give up : we
2257 don't keep it live across functions for now
2260 ic = hTabFirstItemWK(iCodeSeqhTab,OP_SYMBOL(op)->liveFrom);
2261 for (; ic && ic->seq <= OP_SYMBOL(op)->liveTo;
2262 ic = hTabNextItem(iCodeSeqhTab,&key)) {
2265 if (ic->op == CALL || ic->op == PCALL) return 0;
2267 /* single operand icode are ok */
2268 if (ic->op == IFX || ic->op == IPUSH)
2271 if (ic->op == SEND ) {
2272 if (ic->argreg != 1 ) return 0;
2275 /* two special cases first */
2276 if (POINTER_GET(ic) && !isOperandEqual(IC_LEFT(ic),op) && /* pointer get */
2277 !OP_SYMBOL(IC_LEFT(ic))->ruonly && /* with result in far space */
2278 (isOperandInFarSpace(IC_RESULT(ic)) &&
2279 !isOperandInReg(IC_RESULT(ic)))) {
2283 if (POINTER_SET(ic) && !isOperandEqual(IC_RESULT(ic),op) && /* pointer set */
2284 !OP_SYMBOL(IC_RESULT(ic))->ruonly && /* with right in far space */
2285 (isOperandInFarSpace(IC_RIGHT(ic)) &&
2286 !isOperandInReg(IC_RIGHT(ic)))) {
2290 if (IC_RESULT(ic) && IS_SYMOP(IC_RESULT(ic)) && /* if symbol operand */
2291 !isOperandEqual(IC_RESULT(ic),op) && /* not the same as this */
2292 ((isOperandInFarSpace(IC_RESULT(ic)) || /* in farspace or */
2293 OP_SYMBOL(IC_RESULT(ic))->onStack) && /* on the stack */
2294 !isOperandInReg(IC_RESULT(ic)))) { /* and not in register */
2298 if (IC_LEFT(ic) && IS_SYMOP(IC_LEFT(ic)) && /* if symbol operand */
2299 !isOperandEqual(IC_LEFT(ic),op) && /* not the same as this */
2300 ((isOperandInFarSpace(IC_LEFT(ic)) || /* in farspace or */
2301 OP_SYMBOL(IC_LEFT(ic))->onStack) && /* on the stack */
2302 !isOperandInReg(IC_LEFT(ic)))) { /* and not in register */
2305 /* same for right */
2306 if (IC_RIGHT(ic) && IS_SYMOP(IC_RIGHT(ic)) && /* if symbol operand */
2307 !isOperandEqual(IC_RIGHT(ic),op) && /* not the same as this */
2308 ((isOperandInFarSpace(IC_RIGHT(ic)) || /* in farspace or */
2309 OP_SYMBOL(IC_RIGHT(ic))->onStack) && /* on the stack */
2310 !isOperandInReg(IC_RIGHT(ic)))) { /* and not in register */
2314 // Check that no other ops in this range have been assigned to dptr1.
2315 // I don't understand why this is not caught by the first check, above.
2316 // But it isn't always, see bug 769624.
2317 if (IC_RESULT(ic) && IS_SYMOP(IC_RESULT(ic)) &&
2318 (OP_SYMBOL(IC_RESULT(ic))->dptr == 1))
2320 //fprintf(stderr, "dptr1 already in use in live range #1\n");
2324 if (IC_LEFT(ic) && IS_SYMOP(IC_LEFT(ic)) &&
2325 (OP_SYMBOL(IC_LEFT(ic))->dptr == 1))
2327 //fprintf(stderr, "dptr1 already in use in live range # 2\n");
2331 if (IC_RIGHT(ic) && IS_SYMOP(IC_RIGHT(ic)) &&
2332 (OP_SYMBOL(IC_RIGHT(ic))->dptr == 1))
2334 //fprintf(stderr, "dptr1 already in use in live range # 3\n");
2338 if (nfs && IC_RESULT(ic) && IS_SYMOP(IC_RESULT(ic)) &&
2339 OP_SYMBOL(IC_RESULT(ic))->ruonly) return 0;
2341 if (nfs > 1) return 0;
2343 OP_SYMBOL(op)->dptr = dptr;
2347 /*-----------------------------------------------------------------*/
2348 /* packRegsDPTRuse : - will reduce some registers for single Use */
2349 /*-----------------------------------------------------------------*/
2351 packRegsDPTRuse (operand * op)
2353 /* go thru entire liveRange of this variable & check for
2354 other possible usage of DPTR , if we don't find it the
2355 assign this to DPTR (ruonly)
2360 sym_link *type, *etype;
2362 if (!IS_SYMOP(op) || !IS_ITEMP(op)) return NULL;
2363 if (OP_SYMBOL(op)->remat || OP_SYMBOL(op)->ruonly) return NULL;
2365 /* first check if any overlapping liverange has already been
2367 if (OP_SYMBOL(op)->clashes) {
2368 for (i = 0 ; i < OP_SYMBOL(op)->clashes->size ; i++ ) {
2369 if (bitVectBitValue(OP_SYMBOL(op)->clashes,i)) {
2370 sym = hTabItemWithKey(liveRanges,i);
2371 if (sym->ruonly) return NULL ;
2376 /* no then go thru this guys live range */
2377 dic = ic = hTabFirstItemWK(iCodeSeqhTab,OP_SYMBOL(op)->liveFrom);
2378 for (; ic && ic->seq <= OP_SYMBOL(op)->liveTo;
2379 ic = hTabNextItem(iCodeSeqhTab,&key)) {
2381 if (SKIP_IC3(ic)) continue;
2383 /* if PCALL cannot be sure give up */
2384 if (ic->op == PCALL) return NULL;
2386 /* if SEND & not the first parameter then giveup */
2387 if (ic->op == SEND && ic->argreg != 1 &&
2388 ((isOperandInFarSpace(IC_LEFT(ic)) && !isOperandInReg(IC_LEFT(ic))) ||
2389 isOperandEqual(op,IC_LEFT(ic)))) return NULL;
2391 /* if CALL then make sure it is VOID || return value not used
2392 or the return value is assigned to this one */
2393 if (ic->op == CALL) {
2394 if (OP_SYMBOL(IC_RESULT(ic))->liveTo ==
2395 OP_SYMBOL(IC_RESULT(ic))->liveFrom) continue ;
2396 etype = getSpec(type = operandType(IC_RESULT(ic)));
2397 if (getSize(type) == 0 || isOperandEqual(op,IC_RESULT(ic)))
2402 /* special case of add with a [remat] */
2403 if (ic->op == '+' &&
2404 OP_SYMBOL(IC_LEFT(ic))->remat &&
2405 (isOperandInFarSpace(IC_RIGHT(ic)) &&
2406 !isOperandInReg(IC_RIGHT(ic)))) return NULL ;
2410 if (POINTER_GET(ic) && !isOperandEqual(IC_LEFT(ic),op) &&
2411 getSize(operandType(IC_LEFT(ic))) > 1 ) return NULL ;
2414 if (POINTER_SET(ic) && !isOperandEqual(IC_RESULT(ic),op) &&
2415 getSize(operandType(IC_RESULT(ic))) > 1 ) return NULL;
2417 /* conditionals can destroy 'b' - make sure B wont
2418 be used in this one*/
2419 if ((IS_CONDITIONAL(ic) || ic->op == '*' || ic->op == '/' ||
2420 ic->op == LEFT_OP || ic->op == RIGHT_OP ) &&
2421 getSize(operandType(op)) > 3) return NULL;
2423 /* if this is a cast to a bigger type */
2425 if (!IS_PTR(OP_SYM_TYPE(IC_RESULT(ic))) &&
2426 getSize(OP_SYM_TYPE(IC_RESULT(ic))) >
2427 getSize(OP_SYM_TYPE(IC_RIGHT(ic)))) {
2433 if (IC_RESULT(ic) && IS_SYMOP(IC_RESULT(ic)) &&
2434 !isOperandEqual(IC_RESULT(ic),op) &&
2435 ( ( ( isOperandInFarSpace(IC_RESULT(ic)) || OP_SYMBOL(IC_RESULT(ic))->onStack) &&
2436 !isOperandInReg(IC_RESULT(ic))) ||
2437 OP_SYMBOL(IC_RESULT(ic))->ruonly)) return NULL;
2439 if (IC_RIGHT(ic) && IS_SYMOP(IC_RIGHT(ic)) &&
2440 !isOperandEqual(IC_RIGHT(ic),op) &&
2441 (OP_SYMBOL(IC_RIGHT(ic))->liveTo >= ic->seq ||
2442 IS_TRUE_SYMOP(IC_RIGHT(ic)) ||
2443 OP_SYMBOL(IC_RIGHT(ic))->ruonly) &&
2444 ( ( isOperandInFarSpace(IC_RIGHT(ic)) || OP_SYMBOL(IC_RIGHT(ic))->onStack) &&
2445 !isOperandInReg(IC_RIGHT(ic))) ) return NULL;
2447 if (IC_LEFT(ic) && IS_SYMOP(IC_LEFT(ic)) &&
2448 !isOperandEqual(IC_LEFT(ic),op) &&
2449 (OP_SYMBOL(IC_LEFT(ic))->liveTo >= ic->seq ||
2450 IS_TRUE_SYMOP(IC_LEFT(ic)) ||
2451 OP_SYMBOL(IC_LEFT(ic))->ruonly) &&
2452 ( ( isOperandInFarSpace(IC_LEFT(ic)) || OP_SYMBOL(IC_LEFT(ic))->onStack) &&
2453 !isOperandInReg(IC_LEFT(ic))) ) return NULL;
2455 if (IC_LEFT(ic) && IC_RIGHT(ic) &&
2456 IS_ITEMP(IC_LEFT(ic)) && IS_ITEMP(IC_RIGHT(ic)) &&
2457 (isOperandInFarSpace(IC_LEFT(ic)) && !isOperandInReg(IC_LEFT(ic))) &&
2458 (isOperandInFarSpace(IC_RIGHT(ic)) && !isOperandInReg(IC_RIGHT(ic))))
2461 OP_SYMBOL(op)->ruonly = 1;
2462 if (OP_SYMBOL(op)->usl.spillLoc) {
2463 if (OP_SYMBOL(op)->spillA)
2464 OP_SYMBOL(op)->usl.spillLoc->allocreq--;
2465 OP_SYMBOL(op)->usl.spillLoc = NULL;
2470 /*-----------------------------------------------------------------*/
2471 /* isBitwiseOptimizable - requirements of JEAN LOUIS VERN */
2472 /*-----------------------------------------------------------------*/
2474 isBitwiseOptimizable (iCode * ic)
2476 sym_link *ltype = getSpec (operandType (IC_LEFT (ic)));
2477 sym_link *rtype = getSpec (operandType (IC_RIGHT (ic)));
2479 /* bitwise operations are considered optimizable
2480 under the following conditions (Jean-Louis VERN)
2492 if ( IS_LITERAL (rtype) ||
2493 (IS_BITVAR (ltype) && IN_BITSPACE (SPEC_OCLS (ltype))))
2499 /*-----------------------------------------------------------------*/
2500 /* packRegsForAccUse - pack registers for acc use */
2501 /*-----------------------------------------------------------------*/
2503 packRegsForAccUse (iCode * ic)
2507 /* if this is an aggregate, e.g. a one byte char array */
2508 if (IS_AGGREGATE(operandType(IC_RESULT(ic)))) {
2512 /* if we are calling a reentrant function that has stack parameters */
2513 if (ic->op == CALL &&
2514 IFFUNC_ISREENT(operandType(IC_LEFT(ic))) &&
2515 FUNC_HASSTACKPARM(operandType(IC_LEFT(ic))))
2518 if (ic->op == PCALL &&
2519 IFFUNC_ISREENT(operandType(IC_LEFT(ic))->next) &&
2520 FUNC_HASSTACKPARM(operandType(IC_LEFT(ic))->next))
2523 /* if + or - then it has to be one byte result */
2524 if ((ic->op == '+' || ic->op == '-')
2525 && getSize (operandType (IC_RESULT (ic))) > 1)
2528 /* if shift operation make sure right side is not a literal */
2529 if (ic->op == RIGHT_OP &&
2530 (isOperandLiteral (IC_RIGHT (ic)) ||
2531 getSize (operandType (IC_RESULT (ic))) > 1))
2534 if (ic->op == LEFT_OP &&
2535 (isOperandLiteral (IC_RIGHT (ic)) ||
2536 getSize (operandType (IC_RESULT (ic))) > 1))
2539 if (IS_BITWISE_OP (ic) &&
2540 getSize (operandType (IC_RESULT (ic))) > 1)
2544 /* has only one definition */
2545 if (bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) > 1)
2548 /* has only one use */
2549 if (bitVectnBitsOn (OP_USES (IC_RESULT (ic))) > 1)
2552 /* and the usage immediately follows this iCode */
2553 if (!(uic = hTabItemWithKey (iCodehTab,
2554 bitVectFirstBit (OP_USES (IC_RESULT (ic))))))
2557 if (ic->next != uic)
2560 /* if it is a conditional branch then we definitely can */
2564 if (uic->op == JUMPTABLE)
2567 /* if the usage is not is an assignment
2568 or an arithmetic / bitwise / shift operation then not */
2569 if (POINTER_SET (uic) &&
2570 getSize (aggrToPtr (operandType (IC_RESULT (uic)), FALSE)) > 1)
2573 if (uic->op != '=' &&
2574 !IS_ARITHMETIC_OP (uic) &&
2575 !IS_BITWISE_OP (uic) &&
2576 uic->op != LEFT_OP &&
2577 uic->op != RIGHT_OP)
2580 /* if used in ^ operation then make sure right is not a
2582 if (uic->op == '^' && isOperandLiteral (IC_RIGHT (uic)))
2585 /* if shift operation make sure right side is not a literal */
2586 if (uic->op == RIGHT_OP &&
2587 (isOperandLiteral (IC_RIGHT (uic)) ||
2588 getSize (operandType (IC_RESULT (uic))) > 1))
2591 if (uic->op == LEFT_OP &&
2592 (isOperandLiteral (IC_RIGHT (uic)) ||
2593 getSize (operandType (IC_RESULT (uic))) > 1))
2596 /* make sure that the result of this icode is not on the
2597 stack, since acc is used to compute stack offset */
2598 if (isOperandOnStack(IC_RESULT(uic)))
2601 /* if either one of them in far space then we cannot */
2602 if ((IS_TRUE_SYMOP (IC_LEFT (uic)) &&
2603 isOperandInFarSpace (IC_LEFT (uic))) ||
2604 (IS_TRUE_SYMOP (IC_RIGHT (uic)) &&
2605 isOperandInFarSpace (IC_RIGHT (uic))))
2608 /* if the usage has only one operand then we can */
2609 if (IC_LEFT (uic) == NULL ||
2610 IC_RIGHT (uic) == NULL)
2613 /* make sure this is on the left side if not
2614 a '+' since '+' is commutative */
2615 if (ic->op != '+' &&
2616 IC_LEFT (uic)->key != IC_RESULT (ic)->key)
2619 /* if the other one is not on stack then we can */
2620 if (IC_LEFT (uic)->key == IC_RESULT (ic)->key &&
2621 (IS_ITEMP (IC_RIGHT (uic)) ||
2622 (IS_TRUE_SYMOP (IC_RIGHT (uic)) &&
2623 !OP_SYMBOL (IC_RIGHT (uic))->onStack)))
2626 if (IC_RIGHT (uic)->key == IC_RESULT (ic)->key &&
2627 (IS_ITEMP (IC_LEFT (uic)) ||
2628 (IS_TRUE_SYMOP (IC_LEFT (uic)) &&
2629 !OP_SYMBOL (IC_LEFT (uic))->onStack)))
2635 OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
2640 /*-----------------------------------------------------------------*/
2641 /* packForPush - hueristics to reduce iCode for pushing */
2642 /*-----------------------------------------------------------------*/
2644 packForPush (iCode * ic, eBBlock * ebp)
2649 if ((ic->op != IPUSH && ic->op != SEND) || !IS_ITEMP (IC_LEFT (ic)))
2652 /* must have only definition & one usage */
2653 if (bitVectnBitsOn (OP_DEFS (IC_LEFT (ic))) != 1 ||
2654 bitVectnBitsOn (OP_USES (IC_LEFT (ic))) != 1)
2657 /* find the definition */
2658 if (!(dic = hTabItemWithKey (iCodehTab,
2659 bitVectFirstBit (OP_DEFS (IC_LEFT (ic))))))
2662 if (dic->op != '=' || POINTER_SET (dic))
2665 if (dic->eBBlockNum != ic->eBBlockNum) return ;
2667 /* make sure the right side does not have any definitions
2669 dbv = OP_DEFS(IC_RIGHT(dic));
2670 for (lic = ic; lic && lic != dic ; lic = lic->prev) {
2671 if (bitVectBitValue(dbv,lic->key)) return ;
2673 /* make sure they have the same type */
2674 if (IS_SPEC(operandType(IC_LEFT(ic))))
2676 sym_link *itype=operandType(IC_LEFT(ic));
2677 sym_link *ditype=operandType(IC_RIGHT(dic));
2679 if (SPEC_USIGN(itype)!=SPEC_USIGN(ditype) ||
2680 SPEC_LONG(itype)!=SPEC_LONG(ditype))
2683 /* extend the live range of replaced operand if needed */
2684 if (OP_SYMBOL(IC_RIGHT(dic))->liveTo < OP_SYMBOL(IC_LEFT(ic))->liveTo) {
2685 OP_SYMBOL(IC_RIGHT(dic))->liveTo = OP_SYMBOL(IC_LEFT(ic))->liveTo;
2686 OP_SYMBOL(IC_RIGHT(dic))->clashes =
2687 bitVectUnion(OP_SYMBOL(IC_RIGHT(dic))->clashes,
2688 OP_SYMBOL(IC_LEFT(ic))->clashes);
2690 for (lic = ic; lic && lic != dic; lic = lic->prev)
2692 bitVectUnSetBit (lic->rlive, IC_LEFT (ic)->key);
2693 if (IS_ITEMP (IC_RIGHT (dic)))
2694 bitVectSetBit (lic->rlive, IC_RIGHT (dic)->key);
2696 /* we now we know that it has one & only one def & use
2697 and the that the definition is an assignment */
2698 IC_LEFT (ic) = IC_RIGHT (dic);
2700 remiCodeFromeBBlock (ebp, dic);
2701 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2702 hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2705 /*-----------------------------------------------------------------*/
2706 /* packRegisters - does some transformations to reduce register */
2708 /*-----------------------------------------------------------------*/
2710 packRegisters (eBBlock * ebp)
2720 /* look for assignments of the form */
2721 /* iTempNN = TRueSym (someoperation) SomeOperand */
2723 /* TrueSym := iTempNN:1 */
2724 for (ic = ebp->sch; ic; ic = ic->next)
2728 /* find assignment of the form TrueSym := iTempNN:1 */
2729 if (ic->op == '=' && !POINTER_SET (ic))
2730 change += packRegsForAssign (ic, ebp);
2737 for (ic = ebp->sch; ic; ic = ic->next)
2740 /* if this is an itemp & result of a address of a true sym
2741 then mark this as rematerialisable */
2742 if (ic->op == ADDRESS_OF &&
2743 IS_ITEMP (IC_RESULT (ic)) &&
2744 IS_TRUE_SYMOP (IC_LEFT (ic)) &&
2745 bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
2746 !OP_SYMBOL (IC_LEFT (ic))->onStack)
2749 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2750 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2751 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2755 /* if this is an itemp & used as a pointer
2756 & assigned to a literal then remat */
2757 if (IS_ASSIGN_ICODE(ic) &&
2758 IS_ITEMP(IC_RESULT(ic)) &&
2759 bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
2760 isOperandLiteral(IC_RIGHT(ic)))
2762 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2763 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2764 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2767 /* if straight assignment then carry remat flag if
2768 this is the only definition */
2769 if (ic->op == '=' &&
2770 !POINTER_SET (ic) &&
2771 IS_SYMOP (IC_RIGHT (ic)) &&
2772 OP_SYMBOL (IC_RIGHT (ic))->remat &&
2773 !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode) &&
2774 bitVectnBitsOn (OP_SYMBOL (IC_RESULT (ic))->defs) <= 1)
2777 OP_SYMBOL (IC_RESULT (ic))->remat =
2778 OP_SYMBOL (IC_RIGHT (ic))->remat;
2779 OP_SYMBOL (IC_RESULT (ic))->rematiCode =
2780 OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
2783 /* if cast to a generic pointer & the pointer being
2784 cast is remat, then we can remat this cast as well */
2785 if (ic->op == CAST &&
2786 IS_SYMOP(IC_RIGHT(ic)) &&
2787 !OP_SYMBOL(IC_RESULT(ic))->isreqv &&
2788 OP_SYMBOL(IC_RIGHT(ic))->remat ) {
2789 sym_link *to_type = operandType(IC_LEFT(ic));
2790 sym_link *from_type = operandType(IC_RIGHT(ic));
2791 if (IS_GENPTR(to_type) && IS_PTR(from_type)) {
2792 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2793 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2794 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2798 /* if this is a +/- operation with a rematerizable
2799 then mark this as rematerializable as well */
2800 if ((ic->op == '+' || ic->op == '-') &&
2801 (IS_SYMOP (IC_LEFT (ic)) &&
2802 IS_ITEMP (IC_RESULT (ic)) &&
2803 OP_SYMBOL (IC_LEFT (ic))->remat &&
2804 (!IS_SYMOP (IC_RIGHT (ic)) || !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode)) &&
2805 bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
2806 IS_OP_LITERAL (IC_RIGHT (ic))))
2809 //int i = operandLitValue(IC_RIGHT(ic));
2810 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2811 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2812 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2815 /* mark the pointer usages */
2816 if (POINTER_SET (ic) && IS_SYMOP (IC_RESULT (ic)))
2817 OP_SYMBOL (IC_RESULT (ic))->uptr = 1;
2819 if (POINTER_GET (ic) && IS_SYMOP (IC_LEFT (ic)))
2820 OP_SYMBOL (IC_LEFT (ic))->uptr = 1;
2822 if (ic->op == RETURN && IS_SYMOP (IC_LEFT(ic)))
2823 OP_SYMBOL (IC_LEFT (ic))->uptr = 1;
2825 if (ic->op == RECEIVE && ic->argreg == 1 &&
2826 IS_SYMOP (IC_RESULT (ic)) &&
2827 getSize (operandType(IC_RESULT(ic))) <= 3)
2828 OP_SYMBOL (IC_RESULT(ic))->uptr = 1;
2830 if (ic->op == SEND && ic->argreg == 1 &&
2831 IS_SYMOP(IC_LEFT(ic)) &&
2832 getSize (aggrToPtr(operandType(IC_LEFT(ic)),FALSE)) <= 3)
2833 OP_SYMBOL (IC_LEFT(ic))->uptr = 1;
2837 /* if we are using a symbol on the stack
2838 then we should say ds390_ptrRegReq */
2839 if (ic->op == IFX && IS_SYMOP (IC_COND (ic)))
2840 ds390_ptrRegReq += ((OP_SYMBOL (IC_COND (ic))->onStack ? !options.stack10bit : 0) +
2841 OP_SYMBOL (IC_COND (ic))->iaccess);
2842 else if (ic->op == JUMPTABLE && IS_SYMOP (IC_JTCOND (ic)))
2843 ds390_ptrRegReq += ((OP_SYMBOL (IC_JTCOND (ic))->onStack ? !options.stack10bit : 0) +
2844 OP_SYMBOL (IC_JTCOND (ic))->iaccess);
2847 if (IS_SYMOP (IC_LEFT (ic)))
2848 ds390_ptrRegReq += ((OP_SYMBOL (IC_LEFT (ic))->onStack ? !options.stack10bit : 0) +
2849 OP_SYMBOL (IC_LEFT (ic))->iaccess);
2850 if (IS_SYMOP (IC_RIGHT (ic)))
2851 ds390_ptrRegReq += ((OP_SYMBOL (IC_RIGHT (ic))->onStack ? !options.stack10bit : 0) +
2852 OP_SYMBOL (IC_RIGHT (ic))->iaccess);
2853 if (IS_SYMOP (IC_RESULT (ic)))
2854 ds390_ptrRegReq += ((OP_SYMBOL (IC_RESULT (ic))->onStack ? !options.stack10bit : 0) +
2855 OP_SYMBOL (IC_RESULT (ic))->iaccess);
2859 /* if the condition of an if instruction
2860 is defined in the previous instruction and
2861 this is the only usage then
2862 mark the itemp as a conditional */
2863 if ((IS_CONDITIONAL (ic) ||
2864 (IS_BITWISE_OP(ic) && isBitwiseOptimizable (ic))) &&
2865 ic->next && ic->next->op == IFX &&
2866 bitVectnBitsOn (OP_USES(IC_RESULT(ic)))==1 &&
2867 isOperandEqual (IC_RESULT (ic), IC_COND (ic->next)) &&
2868 OP_SYMBOL (IC_RESULT (ic))->liveTo <= ic->next->seq)
2870 OP_SYMBOL (IC_RESULT (ic))->regType = REG_CND;
2874 /* reduce for support function calls */
2875 if (ic->supportRtn || ic->op == '+' || ic->op == '-')
2876 packRegsForSupport (ic, ebp);
2878 /* some cases the redundant moves can
2879 can be eliminated for return statements . Can be elminated for the first SEND */
2880 if ((ic->op == RETURN ||
2881 ((ic->op == SEND || ic->op == RECEIVE)&& ic->argreg == 1)) &&
2882 !isOperandInFarSpace (IC_LEFT (ic)) &&
2885 packRegsDPTRuse (IC_LEFT (ic));
2888 if (ic->op == CALL) {
2889 sym_link *ftype = operandType(IC_LEFT(ic));
2890 if (getSize(operandType(IC_RESULT(ic))) <= 4 &&
2891 !IFFUNC_ISBUILTIN(ftype)) {
2892 packRegsDPTRuse (IC_RESULT (ic));
2896 /* if pointer set & left has a size more than
2897 one and right is not in far space */
2898 if (POINTER_SET (ic) &&
2899 !isOperandInFarSpace (IC_RIGHT (ic)) &&
2900 IS_SYMOP (IC_RESULT (ic)) &&
2901 !OP_SYMBOL (IC_RESULT (ic))->remat &&
2902 !IS_OP_RUONLY (IC_RIGHT (ic)) &&
2903 getSize (aggrToPtr (operandType (IC_RESULT (ic)), FALSE)) > 1) {
2905 packRegsDPTRuse (IC_RESULT (ic));
2908 /* if pointer get */
2909 if (POINTER_GET (ic) &&
2910 !isOperandInFarSpace (IC_RESULT (ic)) &&
2911 IS_SYMOP (IC_LEFT (ic)) &&
2912 !OP_SYMBOL (IC_LEFT (ic))->remat &&
2913 !IS_OP_RUONLY (IC_RESULT (ic)) &&
2914 getSize (aggrToPtr (operandType (IC_LEFT (ic)), FALSE)) > 1) {
2916 packRegsDPTRuse (IC_LEFT (ic));
2919 /* if this is cast for intergral promotion then
2920 check if only use of the definition of the
2921 operand being casted/ if yes then replace
2922 the result of that arithmetic operation with
2923 this result and get rid of the cast */
2926 sym_link *fromType = operandType (IC_RIGHT (ic));
2927 sym_link *toType = operandType (IC_LEFT (ic));
2929 if (IS_INTEGRAL (fromType) && IS_INTEGRAL (toType) &&
2930 getSize (fromType) != getSize (toType) &&
2931 SPEC_USIGN (fromType) == SPEC_USIGN (toType))
2934 iCode *dic = packRegsDPTRuse (IC_RIGHT (ic));
2937 if (IS_ARITHMETIC_OP (dic))
2939 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2940 IC_RESULT (dic) = IC_RESULT (ic);
2941 remiCodeFromeBBlock (ebp, ic);
2942 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
2943 hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
2944 OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
2948 OP_SYMBOL (IC_RIGHT (ic))->ruonly = 0;
2954 /* if the type from and type to are the same
2955 then if this is the only use then packit */
2956 if (compareType (operandType (IC_RIGHT (ic)),
2957 operandType (IC_LEFT (ic))) == 1)
2959 iCode *dic = packRegsDPTRuse (IC_RIGHT (ic));
2962 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
2963 IC_RESULT (dic) = IC_RESULT (ic);
2964 remiCodeFromeBBlock (ebp, ic);
2965 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
2966 hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
2967 OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
2975 iTempNN := (some variable in farspace) V1
2980 if (ic->op == IPUSH || ic->op == SEND)
2982 packForPush (ic, ebp);
2986 /* pack registers for accumulator use, when the
2987 result of an arithmetic or bit wise operation
2988 has only one use, that use is immediately following
2989 the defintion and the using iCode has only one
2990 operand or has two operands but one is literal &
2991 the result of that operation is not on stack then
2992 we can leave the result of this operation in acc:b
2994 if ((IS_ARITHMETIC_OP (ic)
2995 || IS_CONDITIONAL(ic)
2996 || IS_BITWISE_OP (ic)
2997 || ic->op == LEFT_OP || ic->op == RIGHT_OP
2998 || (ic->op == ADDRESS_OF && isOperandOnStack (IC_LEFT (ic)))
3000 IS_ITEMP (IC_RESULT (ic)) &&
3001 getSize (operandType (IC_RESULT (ic))) <= 2)
3003 packRegsForAccUse (ic);
3008 /*-----------------------------------------------------------------*/
3009 /* assignRegisters - assigns registers to each live range as need */
3010 /*-----------------------------------------------------------------*/
3012 ds390_assignRegisters (eBBlock ** ebbs, int count)
3017 setToNull ((void *) &_G.funcrUsed);
3018 setToNull ((void *) &_G.regAssigned);
3019 setToNull ((void *) &_G.totRegAssigned);
3020 setToNull ((void *) &_G.funcrUsed);
3021 ds390_ptrRegReq = _G.stackExtend = _G.dataExtend = 0;
3023 if (options.model != MODEL_FLAT24) options.stack10bit = 0;
3024 /* change assignments this will remove some
3025 live ranges reducing some register pressure */
3026 for (i = 0; i < count; i++)
3027 packRegisters (ebbs[i]);
3029 /* liveranges probably changed by register packing
3030 so we compute them again */
3031 recomputeLiveRanges (ebbs, count);
3033 if (options.dump_pack)
3034 dumpEbbsToFileExt (DUMP_PACK, ebbs, count);
3036 /* first determine for each live range the number of
3037 registers & the type of registers required for each */
3040 /* and serially allocate registers */
3041 serialRegAssign (ebbs, count);
3048 /* if stack was extended then tell the user */
3051 /* werror(W_TOOMANY_SPILS,"stack", */
3052 /* _G.stackExtend,currFunc->name,""); */
3058 /* werror(W_TOOMANY_SPILS,"data space", */
3059 /* _G.dataExtend,currFunc->name,""); */
3063 /* after that create the register mask
3064 for each of the instruction */
3065 createRegMask (ebbs, count);
3067 /* redo that offsets for stacked automatic variables */
3069 redoStackOffsets ();
3071 if (options.dump_rassgn) {
3072 dumpEbbsToFileExt (DUMP_RASSGN, ebbs, count);
3073 dumpLiveRanges (DUMP_LRANGE, liveRanges);
3076 /* do the overlaysegment stuff SDCCmem.c */
3077 doOverlays (ebbs, count);
3079 /* now get back the chain */
3080 ic = iCodeLabelOptimize (iCodeFromeBBlock (ebbs, count));
3085 /* free up any _G.stackSpil locations allocated */
3086 applyToSet (_G.stackSpil, deallocStackSpil);
3088 setToNull ((void *) &_G.stackSpil);
3089 setToNull ((void *) &_G.spiltSet);
3090 /* mark all registers as free */