1 /*------------------------------------------------------------------------
3 SDCCralloc.c - source file for register allocation. (DS80C390) specific
5 Written By - Sandeep Dutta . sandeep.dutta@usa.net (1998)
7 This program is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 2, or (at your option) any
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21 In other words, you are welcome to use, share and improve this program.
22 You are forbidden to forbid anyone else to use, share and improve
23 what you give them. Help stamp out software-hoarding!
24 -------------------------------------------------------------------------*/
30 /*-----------------------------------------------------------------*/
31 /* At this point we start getting processor specific although */
32 /* some routines are non-processor specific & can be reused when */
33 /* targetting other processors. The decision for this will have */
34 /* to be made on a routine by routine basis */
35 /* routines used to pack registers are most definitely not reusable */
36 /* since the pack the registers depending strictly on the MCU */
37 /*-----------------------------------------------------------------*/
47 bitVect *totRegAssigned; /* final set of LRs that got into registers */
50 bitVect *funcrUsed; /* registers used in a function */
53 bitVect *allBitregs; /* all bit registers */
57 /* Shared with gen.c */
58 int ds390_ptrRegReq; /* one byte pointer register required */
64 {REG_GPR, R2_IDX, REG_GPR, "r2", "ar2", "0", 2, 1, 1},
65 {REG_GPR, R3_IDX, REG_GPR, "r3", "ar3", "0", 3, 1, 1},
66 {REG_GPR, R4_IDX, REG_GPR, "r4", "ar4", "0", 4, 1, 1},
67 {REG_GPR, R5_IDX, REG_GPR, "r5", "ar5", "0", 5, 1, 1},
68 {REG_GPR, R6_IDX, REG_GPR, "r6", "ar6", "0", 6, 1, 1},
69 {REG_GPR, R7_IDX, REG_GPR, "r7", "ar7", "0", 7, 1, 1},
70 {REG_PTR, R0_IDX, REG_PTR, "r0", "ar0", "0", 0, 1, 1},
71 {REG_PTR, R1_IDX, REG_PTR, "r1", "ar1", "0", 1, 1, 1},
72 {REG_GPR, DPL_IDX, REG_GPR, "dpl", "dpl", "dpl", 0, 0, 0},
73 {REG_GPR, DPH_IDX, REG_GPR, "dph", "dph", "dph", 0, 0, 0},
74 {REG_GPR, DPX_IDX, REG_GPR, "dpx", "dpx", "dpx", 0, 0, 0},
75 {REG_GPR, B_IDX, REG_GPR, "b", "b", "b", 0, 0, 0},
76 {REG_BIT, B0_IDX, REG_BIT, "b0", "b0", "bits", 0, 1, 0},
77 {REG_BIT, B1_IDX, REG_BIT, "b1", "b1", "bits", 1, 1, 0},
78 {REG_BIT, B2_IDX, REG_BIT, "b2", "b2", "bits", 2, 1, 0},
79 {REG_BIT, B3_IDX, REG_BIT, "b3", "b3", "bits", 3, 1, 0},
80 {REG_BIT, B4_IDX, REG_BIT, "b4", "b4", "bits", 4, 1, 0},
81 {REG_BIT, B5_IDX, REG_BIT, "b5", "b5", "bits", 5, 1, 0},
82 {REG_BIT, B6_IDX, REG_BIT, "b6", "b6", "bits", 6, 1, 0},
83 {REG_BIT, B7_IDX, REG_BIT, "b7", "b7", "bits", 7, 1, 0},
84 {REG_GPR, X8_IDX, REG_GPR, "x8", "x8", "xreg", 0, 0, 0},
85 {REG_GPR, X9_IDX, REG_GPR, "x9", "x9", "xreg", 1, 0, 0},
86 {REG_GPR, X10_IDX, REG_GPR, "x10", "x10", "xreg", 2, 0, 0},
87 {REG_GPR, X11_IDX, REG_GPR, "x11", "x11", "xreg", 3, 0, 0},
88 {REG_GPR, X12_IDX, REG_GPR, "x12", "x12", "xreg", 4, 0, 0},
89 {REG_CND, CND_IDX, REG_GPR, "C", "psw", "xreg", 0, 0, 0},
90 {0, DPL1_IDX, 0, "dpl1", "dpl1", "dpl1", 0, 0, 0},
91 {0, DPH1_IDX, 0, "dph1", "dph1", "dph1", 0, 0, 0},
92 {0, DPX1_IDX, 0, "dpx1", "dpx1", "dpx1", 0, 0, 0},
93 {0, DPS_IDX, 0, "dps", "dps", "dps", 0, 0, 0},
94 {0, A_IDX, 0, "a", "acc", "acc", 0, 0, 0},
95 {0, AP_IDX, 0, "ap", "ap", "ap", 0, 0, 0},
99 int ds390_nBitRegs = 0;
101 static void spillThis (symbol *);
102 static void freeAllRegs ();
103 static iCode * packRegsDPTRuse (operand *);
104 static int packRegsDPTRnuse (operand *,unsigned);
106 /*-----------------------------------------------------------------*/
107 /* allocReg - allocates register of given type */
108 /*-----------------------------------------------------------------*/
110 allocReg (short type)
114 for (i = 0; i < ds390_nRegs; i++)
117 /* if type is given as 0 then any
118 free register will do */
122 regs390[i].isFree = 0;
124 currFunc->regsUsed = bitVectSetBit (currFunc->regsUsed, i);
127 /* otherwise look for specific type of register */
128 if (regs390[i].isFree &&
129 regs390[i].type == type)
131 regs390[i].isFree = 0;
133 currFunc->regsUsed = bitVectSetBit (currFunc->regsUsed, i);
140 /*-----------------------------------------------------------------*/
141 /* ds390_regWithIdx - returns pointer to register with index number*/
142 /*-----------------------------------------------------------------*/
144 ds390_regWithIdx (int idx)
148 for (i = 0; i < sizeof(regs390)/sizeof(regs); i++)
149 if (regs390[i].rIdx == idx)
152 werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
153 "regWithIdx not found");
157 /*-----------------------------------------------------------------*/
158 /* freeReg - frees a register */
159 /*-----------------------------------------------------------------*/
165 werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
166 "freeReg - Freeing NULL register");
173 /*-----------------------------------------------------------------*/
174 /* useReg - marks a register as used */
175 /*-----------------------------------------------------------------*/
182 /*-----------------------------------------------------------------*/
183 /* nFreeRegs - returns number of free registers */
184 /*-----------------------------------------------------------------*/
191 for (i = 0; i < ds390_nRegs; i++)
192 if (regs390[i].isFree && regs390[i].type == type)
197 /*-----------------------------------------------------------------*/
198 /* nfreeRegsType - free registers with type */
199 /*-----------------------------------------------------------------*/
201 nfreeRegsType (int type)
206 if ((nfr = nFreeRegs (type)) == 0)
207 return nFreeRegs (REG_GPR);
210 return nFreeRegs (type);
213 /*-----------------------------------------------------------------*/
214 /* isOperandInReg - returns true if operand is currently in regs */
215 /*-----------------------------------------------------------------*/
216 static int isOperandInReg(operand *op)
218 if (!IS_SYMOP(op)) return 0;
219 if (OP_SYMBOL(op)->ruonly) return 1;
220 if (OP_SYMBOL(op)->accuse) return 1;
221 if (OP_SYMBOL(op)->dptr) return 1;
222 return bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(op)->key);
225 /*-----------------------------------------------------------------*/
226 /* computeSpillable - given a point find the spillable live ranges */
227 /*-----------------------------------------------------------------*/
229 computeSpillable (iCode * ic)
233 /* spillable live ranges are those that are live at this
234 point . the following categories need to be subtracted
236 a) - those that are already spilt
237 b) - if being used by this one
238 c) - defined by this one */
240 spillable = bitVectCopy (ic->rlive);
242 bitVectCplAnd (spillable, _G.spiltSet); /* those already spilt */
244 bitVectCplAnd (spillable, ic->uses); /* used in this one */
245 bitVectUnSetBit (spillable, ic->defKey);
246 spillable = bitVectIntersect (spillable, _G.regAssigned);
251 /*-----------------------------------------------------------------*/
252 /* bitType - will return 1 if the symbol has type REG_BIT */
253 /*-----------------------------------------------------------------*/
255 bitType (symbol * sym, eBBlock * ebp, iCode * ic)
257 return (sym->regType == REG_BIT ? 1 : 0);
260 /*-----------------------------------------------------------------*/
261 /* noSpilLoc - return true if a variable has no spil location */
262 /*-----------------------------------------------------------------*/
264 noSpilLoc (symbol * sym, eBBlock * ebp, iCode * ic)
266 return (sym->usl.spillLoc ? 0 : 1);
269 /*-----------------------------------------------------------------*/
270 /* hasSpilLoc - will return 1 if the symbol has spil location */
271 /*-----------------------------------------------------------------*/
273 hasSpilLoc (symbol * sym, eBBlock * ebp, iCode * ic)
275 return (sym->usl.spillLoc ? 1 : 0);
278 /*-----------------------------------------------------------------*/
279 /* directSpilLoc - will return 1 if the spillocation is in direct */
280 /*-----------------------------------------------------------------*/
282 directSpilLoc (symbol * sym, eBBlock * ebp, iCode * ic)
284 if (sym->usl.spillLoc &&
285 (IN_DIRSPACE (SPEC_OCLS (sym->usl.spillLoc->etype))))
291 /*-----------------------------------------------------------------*/
292 /* hasSpilLocnoUptr - will return 1 if the symbol has spil location */
293 /* but is not used as a pointer */
294 /*-----------------------------------------------------------------*/
296 hasSpilLocnoUptr (symbol * sym, eBBlock * ebp, iCode * ic)
298 return ((sym->usl.spillLoc && !sym->uptr) ? 1 : 0);
301 /*-----------------------------------------------------------------*/
302 /* rematable - will return 1 if the remat flag is set */
303 /*-----------------------------------------------------------------*/
305 rematable (symbol * sym, eBBlock * ebp, iCode * ic)
310 /*-----------------------------------------------------------------*/
311 /* notUsedInRemaining - not used or defined in remain of the block */
312 /*-----------------------------------------------------------------*/
314 notUsedInRemaining (symbol * sym, eBBlock * ebp, iCode * ic)
316 return ((usedInRemaining (operandFromSymbol (sym), ic) ? 0 : 1) &&
317 allDefsOutOfRange (sym->defs, ebp->fSeq, ebp->lSeq));
320 /*-----------------------------------------------------------------*/
321 /* allLRs - return true for all */
322 /*-----------------------------------------------------------------*/
324 allLRs (symbol * sym, eBBlock * ebp, iCode * ic)
329 /*-----------------------------------------------------------------*/
330 /* liveRangesWith - applies function to a given set of live range */
331 /*-----------------------------------------------------------------*/
333 liveRangesWith (bitVect * lrs, int (func) (symbol *, eBBlock *, iCode *),
334 eBBlock * ebp, iCode * ic)
339 if (!lrs || !lrs->size)
342 for (i = 1; i < lrs->size; i++)
345 if (!bitVectBitValue (lrs, i))
348 /* if we don't find it in the live range
349 hash table we are in serious trouble */
350 if (!(sym = hTabItemWithKey (liveRanges, i)))
352 werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
353 "liveRangesWith could not find liveRange");
357 if (func (sym, ebp, ic) && bitVectBitValue (_G.regAssigned, sym->key))
358 addSetHead (&rset, sym);
365 /*-----------------------------------------------------------------*/
366 /* leastUsedLR - given a set determines which is the least used */
367 /*-----------------------------------------------------------------*/
369 leastUsedLR (set * sset)
371 symbol *sym = NULL, *lsym = NULL;
373 sym = lsym = setFirstItem (sset);
378 for (; lsym; lsym = setNextItem (sset))
381 /* if usage is the same then prefer
382 to spill the smaller of the two */
383 if (lsym->used == sym->used)
384 if (getSize (lsym->type) < getSize (sym->type))
388 if (lsym->used < sym->used)
393 setToNull ((void *) &sset);
398 /*-----------------------------------------------------------------*/
399 /* noOverLap - will iterate through the list looking for over lap */
400 /*-----------------------------------------------------------------*/
402 noOverLap (set * itmpStack, symbol * fsym)
406 for (sym = setFirstItem (itmpStack); sym;
407 sym = setNextItem (itmpStack))
409 if (bitVectBitValue(sym->clashes,fsym->key)) return 0;
414 /*-----------------------------------------------------------------*/
415 /* isFree - will return 1 if the a free spil location is found */
416 /*-----------------------------------------------------------------*/
421 V_ARG (symbol **, sloc);
422 V_ARG (symbol *, fsym);
424 /* if already found */
428 /* if it is free && and the itmp assigned to
429 this does not have any overlapping live ranges
430 with the one currently being assigned and
431 the size can be accomodated */
433 noOverLap (sym->usl.itmpStack, fsym) &&
434 getSize (sym->type) >= getSize (fsym->type))
443 /*-----------------------------------------------------------------*/
444 /* spillLRWithPtrReg :- will spil those live ranges which use PTR */
445 /*-----------------------------------------------------------------*/
447 spillLRWithPtrReg (symbol * forSym)
453 if (!_G.regAssigned ||
454 bitVectIsZero (_G.regAssigned))
457 r0 = ds390_regWithIdx (R0_IDX);
458 r1 = ds390_regWithIdx (R1_IDX);
460 /* for all live ranges */
461 for (lrsym = hTabFirstItem (liveRanges, &k); lrsym;
462 lrsym = hTabNextItem (liveRanges, &k))
466 /* if no registers assigned to it or spilt */
467 /* if it does not overlap this then
468 no need to spill it */
470 if (lrsym->isspilt || !lrsym->nRegs ||
471 (lrsym->liveTo < forSym->liveFrom))
474 /* go thru the registers : if it is either
475 r0 or r1 then spill it */
476 for (j = 0; j < lrsym->nRegs; j++)
477 if (lrsym->regs[j] == r0 ||
478 lrsym->regs[j] == r1)
487 /*-----------------------------------------------------------------*/
488 /* createStackSpil - create a location on the stack to spil */
489 /*-----------------------------------------------------------------*/
491 createStackSpil (symbol * sym)
494 int useXstack, model, noOverlay;
498 /* first go try and find a free one that is already
499 existing on the stack */
500 if (applyToSet (_G.stackSpil, isFree, &sloc, sym))
502 /* found a free one : just update & return */
503 sym->usl.spillLoc = sloc;
506 addSetHead (&sloc->usl.itmpStack, sym);
510 /* could not then have to create one , this is the hard part
511 we need to allocate this on the stack : this is really a
512 hack!! but cannot think of anything better at this time */
514 if (SNPRINTF (slocBuffer, sizeof(slocBuffer),
515 "sloc%d", _G.slocNum++) >= sizeof (slocBuffer))
517 fprintf (stderr, "***Internal error: slocBuffer overflowed: %s:%d\n",
522 sloc = newiTemp (slocBuffer);
524 /* set the type to the spilling symbol */
525 sloc->type = copyLinkChain (sym->type);
526 sloc->etype = getSpec (sloc->type);
527 if (!IS_BIT (sloc->etype))
529 if (options.model == MODEL_SMALL)
531 SPEC_SCLS (sloc->etype) = S_DATA;
535 SPEC_SCLS (sloc->etype) = S_XDATA;
538 SPEC_EXTR (sloc->etype) = 0;
539 SPEC_STAT (sloc->etype) = 0;
540 SPEC_VOLATILE(sloc->etype) = 0;
541 SPEC_ABSA(sloc->etype) = 0;
543 /* we don't allow it to be allocated
544 onto the external stack since : so we
545 temporarily turn it off ; we also
546 turn off memory model to prevent
547 the spil from going to the external storage
548 and turn off overlaying
551 useXstack = options.useXstack;
552 model = options.model;
553 noOverlay = options.noOverlay;
554 options.noOverlay = 1;
556 /* options.model = options.useXstack = 0; */
560 options.useXstack = useXstack;
561 options.model = model;
562 options.noOverlay = noOverlay;
563 sloc->isref = 1; /* to prevent compiler warning */
565 /* if it is on the stack then update the stack */
566 if (IN_STACK (sloc->etype))
568 currFunc->stack += getSize (sloc->type);
569 _G.stackExtend += getSize (sloc->type);
572 _G.dataExtend += getSize (sloc->type);
574 /* add it to the _G.stackSpil set */
575 addSetHead (&_G.stackSpil, sloc);
576 sym->usl.spillLoc = sloc;
579 /* add it to the set of itempStack set
580 of the spill location */
581 addSetHead (&sloc->usl.itmpStack, sym);
585 /*-----------------------------------------------------------------*/
586 /* isSpiltOnStack - returns true if the spil location is on stack */
587 /*-----------------------------------------------------------------*/
589 isSpiltOnStack (symbol * sym)
599 /* if (sym->_G.stackSpil) */
602 if (!sym->usl.spillLoc)
605 etype = getSpec (sym->usl.spillLoc->type);
606 if (IN_STACK (etype))
612 /*-----------------------------------------------------------------*/
613 /* spillThis - spils a specific operand */
614 /*-----------------------------------------------------------------*/
616 spillThis (symbol * sym)
619 /* if this is rematerializable or has a spillLocation
620 we are okay, else we need to create a spillLocation
622 if (!(sym->remat || sym->usl.spillLoc))
623 createStackSpil (sym);
625 /* mark it has spilt & put it in the spilt set */
626 sym->isspilt = sym->spillA = 1;
627 _G.spiltSet = bitVectSetBit (_G.spiltSet, sym->key);
629 bitVectUnSetBit (_G.regAssigned, sym->key);
630 bitVectUnSetBit (_G.totRegAssigned, sym->key);
632 for (i = 0; i < sym->nRegs; i++)
636 freeReg (sym->regs[i]);
640 /* if spilt on stack then free up r0 & r1
641 if they could have been assigned to some
643 if (!ds390_ptrRegReq && isSpiltOnStack (sym) && !options.stack10bit)
646 spillLRWithPtrReg (sym);
649 if (sym->usl.spillLoc && !sym->remat)
650 sym->usl.spillLoc->allocreq++;
654 /*-----------------------------------------------------------------*/
655 /* selectSpil - select a iTemp to spil : rather a simple procedure */
656 /*-----------------------------------------------------------------*/
658 selectSpil (iCode * ic, eBBlock * ebp, symbol * forSym)
660 bitVect *lrcs = NULL;
664 /* get the spillable live ranges */
665 lrcs = computeSpillable (ic);
667 /* remove incompatible registers */
668 if ((forSym->regType == REG_PTR) || (forSym->regType == REG_GPR))
670 selectS = liveRangesWith (lrcs, bitType, ebp, ic);
672 for (sym = setFirstItem (selectS); sym; sym = setNextItem (selectS))
674 bitVectUnSetBit (lrcs, sym->key);
678 /* get all live ranges that are rematerializable */
679 if ((selectS = liveRangesWith (lrcs, rematable, ebp, ic)))
681 /* return the least used of these */
682 return leastUsedLR (selectS);
685 /* get live ranges with spillLocations in direct space */
686 if ((selectS = liveRangesWith (lrcs, directSpilLoc, ebp, ic)))
688 sym = leastUsedLR (selectS);
689 strncpyz (sym->rname,
690 sym->usl.spillLoc->rname[0] ?
691 sym->usl.spillLoc->rname : sym->usl.spillLoc->name,
694 /* mark it as allocation required */
695 sym->usl.spillLoc->allocreq++;
699 /* if the symbol is local to the block then */
700 if (forSym->liveTo < ebp->lSeq)
702 /* check if there are any live ranges allocated
703 to registers that are not used in this block */
704 if (!_G.blockSpil && (selectS = liveRangesWith (lrcs, notUsedInBlock, ebp, ic)))
706 sym = leastUsedLR (selectS);
707 /* if this is not rematerializable */
716 /* check if there are any live ranges that not
717 used in the remainder of the block */
719 !isiCodeInFunctionCall (ic) &&
720 (selectS = liveRangesWith (lrcs, notUsedInRemaining, ebp, ic)))
722 sym = leastUsedLR (selectS);
735 /* find live ranges with spillocation && not used as pointers */
736 if ((selectS = liveRangesWith (lrcs, hasSpilLocnoUptr, ebp, ic)))
738 sym = leastUsedLR (selectS);
739 /* mark this as allocation required */
740 sym->usl.spillLoc->allocreq++;
744 /* find live ranges with spillocation */
745 if ((selectS = liveRangesWith (lrcs, hasSpilLoc, ebp, ic)))
747 sym = leastUsedLR (selectS);
748 sym->usl.spillLoc->allocreq++;
752 /* couldn't find then we need to create a spil
753 location on the stack , for which one? the least
755 if ((selectS = liveRangesWith (lrcs, noSpilLoc, ebp, ic)))
757 /* return a created spil location */
758 sym = createStackSpil (leastUsedLR (selectS));
759 sym->usl.spillLoc->allocreq++;
763 /* this is an extreme situation we will spill
764 this one : happens very rarely but it does happen */
770 /*-----------------------------------------------------------------*/
771 /* spilSomething - spil some variable & mark registers as free */
772 /*-----------------------------------------------------------------*/
774 spilSomething (iCode * ic, eBBlock * ebp, symbol * forSym)
779 /* get something we can spil */
780 ssym = selectSpil (ic, ebp, forSym);
782 /* mark it as spilt */
783 ssym->isspilt = ssym->spillA = 1;
784 _G.spiltSet = bitVectSetBit (_G.spiltSet, ssym->key);
786 /* mark it as not register assigned &
787 take it away from the set */
788 bitVectUnSetBit (_G.regAssigned, ssym->key);
789 bitVectUnSetBit (_G.totRegAssigned, ssym->key);
791 /* mark the registers as free */
792 for (i = 0; i < ssym->nRegs; i++)
794 freeReg (ssym->regs[i]);
796 /* if spilt on stack then free up r0 & r1
797 if they could have been assigned to as gprs */
798 if (!ds390_ptrRegReq && isSpiltOnStack (ssym) && !options.stack10bit)
801 spillLRWithPtrReg (ssym);
804 /* if this was a block level spil then insert push & pop
805 at the start & end of block respectively */
808 iCode *nic = newiCode (IPUSH, operandFromSymbol (ssym), NULL);
809 /* add push to the start of the block */
810 addiCodeToeBBlock (ebp, nic, (ebp->sch->op == LABEL ?
811 ebp->sch->next : ebp->sch));
812 nic = newiCode (IPOP, operandFromSymbol (ssym), NULL);
813 /* add pop to the end of the block */
814 addiCodeToeBBlock (ebp, nic, NULL);
817 /* if spilt because not used in the remainder of the
818 block then add a push before this instruction and
819 a pop at the end of the block */
820 if (ssym->remainSpil)
823 iCode *nic = newiCode (IPUSH, operandFromSymbol (ssym), NULL);
824 /* add push just before this instruction */
825 addiCodeToeBBlock (ebp, nic, ic);
827 nic = newiCode (IPOP, operandFromSymbol (ssym), NULL);
828 /* add pop to the end of the block */
829 addiCodeToeBBlock (ebp, nic, NULL);
838 /*-----------------------------------------------------------------*/
839 /* getRegPtr - will try for PTR if not a GPR type if not spil */
840 /*-----------------------------------------------------------------*/
842 getRegPtr (iCode * ic, eBBlock * ebp, symbol * sym)
848 /* try for a ptr type */
849 if ((reg = allocReg (REG_PTR)))
852 /* try for gpr type */
853 if ((reg = allocReg (REG_GPR)))
856 /* we have to spil */
857 if (!spilSomething (ic, ebp, sym))
860 /* make sure partially assigned registers aren't reused */
861 for (j=0; j<=sym->nRegs; j++)
863 sym->regs[j]->isFree = 0;
865 /* this looks like an infinite loop but
866 in really selectSpil will abort */
870 /*-----------------------------------------------------------------*/
871 /* getRegGpr - will try for GPR if not spil */
872 /*-----------------------------------------------------------------*/
874 getRegGpr (iCode * ic, eBBlock * ebp, symbol * sym)
880 /* try for gpr type */
881 if ((reg = allocReg (REG_GPR)))
884 if (!ds390_ptrRegReq)
885 if ((reg = allocReg (REG_PTR)))
888 /* we have to spil */
889 if (!spilSomething (ic, ebp, sym))
892 /* make sure partially assigned registers aren't reused */
893 for (j=0; j<=sym->nRegs; j++)
895 sym->regs[j]->isFree = 0;
897 /* this looks like an infinite loop but
898 in really selectSpil will abort */
902 /*-----------------------------------------------------------------*/
903 /* getRegBit - will try for Bit if not spill this */
904 /*-----------------------------------------------------------------*/
905 static regs *getRegBit (symbol * sym)
909 /* try for a bit type */
910 if ((reg = allocReg (REG_BIT)))
917 /*-----------------------------------------------------------------*/
918 /* getRegPtrNoSpil - get it cannot be spilt */
919 /*-----------------------------------------------------------------*/
920 static regs *getRegPtrNoSpil()
924 /* try for a ptr type */
925 if ((reg = allocReg (REG_PTR)))
928 /* try for gpr type */
929 if ((reg = allocReg (REG_GPR)))
934 /* just to make the compiler happy */
938 /*-----------------------------------------------------------------*/
939 /* getRegGprNoSpil - get it cannot be spilt */
940 /*-----------------------------------------------------------------*/
941 static regs *getRegGprNoSpil()
945 if ((reg = allocReg (REG_GPR)))
948 if (!ds390_ptrRegReq)
949 if ((reg = allocReg (REG_PTR)))
954 /* just to make the compiler happy */
958 /*-----------------------------------------------------------------*/
959 /* getRegBitNoSpil - get it cannot be spilt */
960 /*-----------------------------------------------------------------*/
961 static regs *getRegBitNoSpil()
965 /* try for a bit type */
966 if ((reg = allocReg (REG_BIT)))
969 /* try for gpr type */
970 if ((reg = allocReg (REG_GPR)))
975 /* just to make the compiler happy */
979 /*-----------------------------------------------------------------*/
980 /* symHasReg - symbol has a given register */
981 /*-----------------------------------------------------------------*/
983 symHasReg (symbol * sym, regs * reg)
987 for (i = 0; i < sym->nRegs; i++)
988 if (sym->regs[i] == reg)
994 /*-----------------------------------------------------------------*/
995 /* updateRegUsage - update the registers in use at the start of */
997 /*-----------------------------------------------------------------*/
999 updateRegUsage (iCode * ic)
1003 for (reg=0; reg<ds390_nRegs; reg++)
1005 if (regs390[reg].isFree)
1007 ic->riu &= ~(1<<regs390[reg].offset);
1011 ic->riu |= (1<<regs390[reg].offset);
1012 BitBankUsed |= (reg >= B0_IDX);
1017 /*-----------------------------------------------------------------*/
1018 /* deassignLRs - check the live to and if they have registers & are */
1019 /* not spilt then free up the registers */
1020 /*-----------------------------------------------------------------*/
1022 deassignLRs (iCode * ic, eBBlock * ebp)
1028 for (sym = hTabFirstItem (liveRanges, &k); sym;
1029 sym = hTabNextItem (liveRanges, &k))
1032 symbol *psym = NULL;
1033 /* if it does not end here */
1034 if (sym->liveTo > ic->seq)
1037 /* if it was spilt on stack then we can
1038 mark the stack spil location as free */
1043 sym->usl.spillLoc->isFree = 1;
1049 if (!bitVectBitValue (_G.regAssigned, sym->key))
1052 /* special case check if this is an IFX &
1053 the privious one was a pop and the
1054 previous one was not spilt then keep track
1056 if (ic->op == IFX && ic->prev &&
1057 ic->prev->op == IPOP &&
1058 !ic->prev->parmPush &&
1059 !OP_SYMBOL (IC_LEFT (ic->prev))->isspilt)
1060 psym = OP_SYMBOL (IC_LEFT (ic->prev));
1066 bitVectUnSetBit (_G.regAssigned, sym->key);
1068 /* if the result of this one needs registers
1069 and does not have it then assign it right
1071 if (IC_RESULT (ic) &&
1072 !(SKIP_IC2 (ic) || /* not a special icode */
1073 ic->op == JUMPTABLE ||
1078 POINTER_SET (ic)) &&
1079 (result = OP_SYMBOL (IC_RESULT (ic))) && /* has a result */
1080 result->liveTo > ic->seq && /* and will live beyond this */
1081 result->liveTo <= ebp->lSeq && /* does not go beyond this block */
1082 result->liveFrom == ic->seq && /* does not start before here */
1083 result->regType == sym->regType && /* same register types */
1084 result->nRegs && /* which needs registers */
1085 !result->isspilt && /* and does not already have them */
1087 !bitVectBitValue (_G.regAssigned, result->key) &&
1088 /* the number of free regs + number of regs in this LR
1089 can accomodate the what result Needs */
1090 ((nfreeRegsType (result->regType) +
1091 sym->nRegs) >= result->nRegs)
1095 for (i = 0; i < result->nRegs; i++)
1097 result->regs[i] = sym->regs[i];
1099 result->regs[i] = getRegGpr (ic, ebp, result);
1101 _G.regAssigned = bitVectSetBit (_G.regAssigned, result->key);
1102 _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, result->key);
1106 /* free the remaining */
1107 for (; i < sym->nRegs; i++)
1111 if (!symHasReg (psym, sym->regs[i]))
1112 freeReg (sym->regs[i]);
1115 freeReg (sym->regs[i]);
1122 /*-----------------------------------------------------------------*/
1123 /* reassignLR - reassign this to registers */
1124 /*-----------------------------------------------------------------*/
1126 reassignLR (operand * op)
1128 symbol *sym = OP_SYMBOL (op);
1131 /* not spilt any more */
1132 sym->isspilt = sym->spillA = sym->blockSpil = sym->remainSpil = 0;
1133 bitVectUnSetBit (_G.spiltSet, sym->key);
1135 _G.regAssigned = bitVectSetBit (_G.regAssigned, sym->key);
1136 _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, sym->key);
1140 for (i = 0; i < sym->nRegs; i++)
1141 sym->regs[i]->isFree = 0;
1144 /*-----------------------------------------------------------------*/
1145 /* willCauseSpill - determines if allocating will cause a spill */
1146 /*-----------------------------------------------------------------*/
1148 willCauseSpill (int nr, int rt)
1150 /* first check if there are any available registers
1151 of the type required */
1154 /* special case for pointer type
1155 if pointer type not avlb then
1156 check for type gpr */
1157 if (nFreeRegs (rt) >= nr)
1159 if (nFreeRegs (REG_GPR) >= nr)
1162 else if (rt == REG_BIT)
1164 if (nFreeRegs (rt) >= nr)
1169 if (ds390_ptrRegReq)
1171 if (nFreeRegs (rt) >= nr)
1176 if (nFreeRegs (REG_PTR) +
1177 nFreeRegs (REG_GPR) >= nr)
1182 /* it will cause a spil */
1186 /*-----------------------------------------------------------------*/
1187 /* positionRegs - the allocator can allocate same registers to res- */
1188 /* ult and operand, if this happens make sure they are in the same */
1189 /* position as the operand otherwise chaos results */
1190 /*-----------------------------------------------------------------*/
1192 positionRegs (symbol * result, symbol * opsym)
1194 int count = min (result->nRegs, opsym->nRegs);
1195 int i, j = 0, shared = 0;
1198 /* if the result has been spilt then cannot share */
1203 /* first make sure that they actually share */
1204 for (i = 0; i < count; i++)
1206 for (j = 0; j < count; j++)
1208 if (result->regs[i] == opsym->regs[j] && i != j)
1218 regs *tmp = result->regs[i];
1219 result->regs[i] = result->regs[j];
1220 result->regs[j] = tmp;
1227 /*-----------------------------------------------------------------*/
1228 /* unusedLRS - returns a bitVector of liveranges not used in 'ebp' */
1229 /*-----------------------------------------------------------------*/
1230 bitVect *unusedLRs (eBBlock *ebp)
1232 bitVect *ret = NULL;
1236 if (!ebp) return NULL;
1237 for (sym = hTabFirstItem(liveRanges,&key); sym ;
1238 sym = hTabNextItem(liveRanges,&key)) {
1240 if (notUsedInBlock(sym,ebp,NULL)) {
1241 ret = bitVectSetBit(ret,sym->key);
1248 /*-----------------------------------------------------------------*/
1249 /* deassignUnsedLRs - if this baisc block ends in a return then */
1250 /* deassign symbols not used in this block */
1251 /*-----------------------------------------------------------------*/
1252 bitVect *deassignUnsedLRs(eBBlock *ebp)
1254 bitVect *unused = NULL;
1257 switch (returnAtEnd(ebp)) {
1258 case 2: /* successor block ends in a return */
1259 unused = unusedLRs((eBBlock *) setFirstItem(ebp->succList));
1261 case 1: /* this block ends in a return */
1262 unused = bitVectIntersect(unused,unusedLRs(ebp));
1267 for (i = 0 ; i < unused->size ; i++ ) {
1270 if (bitVectBitValue(unused,i)) {
1272 /* if assigned to registers */
1273 if (bitVectBitValue(_G.regAssigned,i)) {
1277 sym = hTabItemWithKey(liveRanges,i);
1278 /* remove it from regassigned & mark the
1280 bitVectUnSetBit(_G.regAssigned,i);
1281 for (j = 0 ; j < sym->nRegs; j++)
1282 freeReg(sym->regs[j]);
1284 /* not assigned to registers : remove from set*/
1285 bitVectUnSetBit(unused,i);
1293 /*-----------------------------------------------------------------*/
1294 /* reassignUnusedLRs - put registers to unused Live ranges */
1295 /*-----------------------------------------------------------------*/
1296 void reassignUnusedLRs (bitVect *unused)
1299 if (!unused) return ;
1301 for (i = 0 ; i < unused->size ; i++ ) {
1302 /* if unused : means it was assigned to registers before */
1303 if (bitVectBitValue(unused,i)) {
1307 /* put it back into reg set*/
1308 bitVectSetBit(_G.regAssigned,i) ;
1310 sym = hTabItemWithKey(liveRanges,i);
1311 /* make registers busy */
1312 for (j = 0 ; j < sym->nRegs; j++)
1313 sym->regs[j]->isFree = 0;
1318 /*------------------------------------------------------------------*/
1319 /* verifyRegsAssigned - make sure an iTemp is properly initialized; */
1320 /* it should either have registers or have beed spilled. Otherwise, */
1321 /* there was an uninitialized variable, so just spill this to get */
1322 /* the operand in a valid state. */
1323 /*------------------------------------------------------------------*/
1325 verifyRegsAssigned (operand *op, iCode * ic)
1330 if (!IS_ITEMP (op)) return;
1332 sym = OP_SYMBOL (op);
1333 if (sym->isspilt) return;
1334 if (!sym->nRegs) return;
1335 if (sym->regs[0]) return;
1337 werrorfl (ic->filename, ic->lineno, W_LOCAL_NOINIT,
1338 sym->prereqv ? sym->prereqv->name : sym->name);
1343 /*-----------------------------------------------------------------*/
1344 /* serialRegAssign - serially allocate registers to the variables */
1345 /*-----------------------------------------------------------------*/
1347 serialRegAssign (eBBlock ** ebbs, int count)
1351 /* for all blocks */
1352 for (i = 0; i < count; i++)
1356 bitVect *unusedLRs = NULL;
1358 if (ebbs[i]->noPath &&
1359 (ebbs[i]->entryLabel != entryLabel &&
1360 ebbs[i]->entryLabel != returnLabel))
1363 unusedLRs = deassignUnsedLRs(ebbs[i]);
1365 /* for all instructions do */
1366 for (ic = ebbs[i]->sch; ic; ic = ic->next)
1370 /* if this is an ipop that means some live
1371 range will have to be assigned again */
1373 reassignLR (IC_LEFT (ic));
1375 /* if result is present && is a true symbol */
1376 if (IC_RESULT (ic) && ic->op != IFX &&
1377 IS_TRUE_SYMOP (IC_RESULT (ic)))
1378 OP_SYMBOL (IC_RESULT (ic))->allocreq++;
1380 /* take away registers from live
1381 ranges that end at this instruction */
1382 deassignLRs (ic, ebbs[i]);
1384 /* some don't need registers */
1385 if (SKIP_IC2 (ic) ||
1386 ic->op == JUMPTABLE ||
1390 (IC_RESULT (ic) && POINTER_SET (ic)))
1393 /* now we need to allocate registers
1394 only for the result */
1397 symbol *sym = OP_SYMBOL (IC_RESULT (ic));
1403 /* Make sure any spill location is definitely allocated */
1404 if (sym->isspilt && !sym->remat && sym->usl.spillLoc &&
1405 !sym->usl.spillLoc->allocreq)
1407 sym->usl.spillLoc->allocreq++;
1410 /* if it does not need or is spilt
1411 or is already assigned to registers
1412 or will not live beyond this instructions */
1415 bitVectBitValue (_G.regAssigned, sym->key) ||
1416 sym->liveTo <= ic->seq)
1419 /* if some liverange has been spilt at the block level
1420 and this one live beyond this block then spil this
1422 if (_G.blockSpil && sym->liveTo > ebbs[i]->lSeq)
1428 willCS = willCauseSpill (sym->nRegs, sym->regType);
1429 /* if this is a bit variable then don't use precious registers
1430 along with expensive bit-to-char conversions but just spill
1432 if (willCS && SPEC_NOUN(sym->etype) == V_BIT)
1438 /* if trying to allocate this will cause
1439 a spill and there is nothing to spill
1440 or this one is rematerializable then
1442 spillable = computeSpillable (ic);
1443 if (sym->remat || (willCS && bitVectIsZero (spillable)))
1449 /* If the live range preceeds the point of definition
1450 then ideally we must take into account registers that
1451 have been allocated after sym->liveFrom but freed
1452 before ic->seq. This is complicated, so spill this
1453 symbol instead and let fillGaps handle the allocation. */
1454 if (sym->liveFrom < ic->seq)
1460 /* if it has a spillocation & is used less than
1461 all other live ranges then spill this */
1463 if (sym->usl.spillLoc) {
1464 symbol *leastUsed = leastUsedLR (liveRangesWith (spillable,
1465 allLRs, ebbs[i], ic));
1466 if (leastUsed && leastUsed->used > sym->used) {
1471 /* if none of the liveRanges have a spillLocation then better
1472 to spill this one than anything else already assigned to registers */
1473 if (liveRangesWith(spillable,noSpilLoc,ebbs[i],ic)) {
1474 /* if this is local to this block then we might find a block spil */
1475 if (!(sym->liveFrom >= ebbs[i]->fSeq && sym->liveTo <= ebbs[i]->lSeq)) {
1483 /* if we need ptr regs for the right side
1485 if (POINTER_GET (ic) && IS_SYMOP (IC_LEFT (ic))
1486 && getSize (OP_SYMBOL (IC_LEFT (ic))->type) <= (unsigned) PTRSIZE)
1491 /* else we assign registers to it */
1492 _G.regAssigned = bitVectSetBit (_G.regAssigned, sym->key);
1493 _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, sym->key);
1495 for (j = 0; j < sym->nRegs; j++)
1497 sym->regs[j] = NULL;
1498 if (sym->regType == REG_PTR)
1499 sym->regs[j] = getRegPtr (ic, ebbs[i], sym);
1500 else if (sym->regType == REG_BIT)
1501 sym->regs[j] = getRegBit (sym);
1503 sym->regs[j] = getRegGpr (ic, ebbs[i], sym);
1505 /* if the allocation failed which means
1506 this was spilt then break */
1511 /* if it shares registers with operands make sure
1512 that they are in the same position */
1513 if (!POINTER_SET(ic) && !POINTER_GET(ic))
1515 if (IC_LEFT (ic) && IS_SYMOP (IC_LEFT (ic)) &&
1516 OP_SYMBOL (IC_LEFT (ic))->nRegs)
1518 positionRegs (OP_SYMBOL (IC_RESULT (ic)),
1519 OP_SYMBOL (IC_LEFT (ic)));
1521 /* do the same for the right operand */
1522 if (IC_RIGHT (ic) && IS_SYMOP (IC_RIGHT (ic)) &&
1523 OP_SYMBOL (IC_RIGHT (ic))->nRegs)
1525 positionRegs (OP_SYMBOL (IC_RESULT (ic)),
1526 OP_SYMBOL (IC_RIGHT (ic)));
1538 reassignUnusedLRs(unusedLRs);
1541 /* Check for and fix any problems with uninitialized operands */
1542 for (i = 0; i < count; i++)
1546 if (ebbs[i]->noPath &&
1547 (ebbs[i]->entryLabel != entryLabel &&
1548 ebbs[i]->entryLabel != returnLabel))
1551 for (ic = ebbs[i]->sch; ic; ic = ic->next)
1558 verifyRegsAssigned (IC_COND (ic), ic);
1562 if (ic->op == JUMPTABLE)
1564 verifyRegsAssigned (IC_JTCOND (ic), ic);
1568 verifyRegsAssigned (IC_RESULT (ic), ic);
1569 verifyRegsAssigned (IC_LEFT (ic), ic);
1570 verifyRegsAssigned (IC_RIGHT (ic), ic);
1575 /*-----------------------------------------------------------------*/
1576 /* fillGaps - Try to fill in the Gaps left by Pass1 */
1577 /*-----------------------------------------------------------------*/
1578 static void fillGaps()
1582 int loop = 0, change;
1585 if (getenv("DISABLE_FILL_GAPS")) return;
1587 /* First try to do DPTRuse once more since now we know what got into
1590 while (loop++ < 10) {
1593 for (sym = hTabFirstItem(liveRanges,&key) ; sym ;
1594 sym = hTabNextItem(liveRanges,&key)) {
1595 int size = getSize(sym->type);
1597 if (sym->liveFrom == sym->liveTo) continue;
1599 if (sym->uptr && sym->dptr==0 && !sym->ruonly &&
1600 size < 4 && size > 1) {
1602 if (packRegsDPTRuse(operandFromSymbol(sym))) {
1604 /* if this was assigned to registers then */
1605 if (bitVectBitValue(_G.totRegAssigned,sym->key)) {
1606 /* take it out of the register assigned set */
1607 bitVectUnSetBit(_G.totRegAssigned,sym->key);
1608 } else if (sym->usl.spillLoc) {
1609 sym->usl.spillLoc->allocreq--;
1610 sym->usl.spillLoc = NULL;
1614 sym->isspilt = sym->spillA = 0;
1618 /* try assigning other dptrs */
1619 if (sym->dptr == 0 && packRegsDPTRnuse(operandFromSymbol(sym),1) && !getenv("DPTRnDISABLE")) {
1620 /* if this was ssigned to registers then */
1621 if (bitVectBitValue(_G.totRegAssigned,sym->key)) {
1622 /* take it out of the register assigned set */
1623 bitVectUnSetBit(_G.totRegAssigned,sym->key);
1624 } else if (sym->usl.spillLoc) {
1625 sym->usl.spillLoc->allocreq--;
1626 sym->usl.spillLoc = NULL;
1629 sym->isspilt = sym->spillA = 0;
1634 /* look for liveranges that were spilt by the allocator */
1635 for (sym = hTabFirstItem(liveRanges,&key) ; sym ;
1636 sym = hTabNextItem(liveRanges,&key)) {
1641 if (!sym->spillA || !sym->clashes || sym->remat) continue ;
1642 if (!sym->uses || !sym->defs) continue ;
1643 /* find the liveRanges this one clashes with, that are
1644 still assigned to registers & mark the registers as used*/
1645 for ( i = 0 ; i < sym->clashes->size ; i ++) {
1649 if (bitVectBitValue(sym->clashes,i) == 0 || /* those that clash with this */
1650 bitVectBitValue(_G.totRegAssigned,i) == 0) /* and are still assigned to registers */
1653 clr = hTabItemWithKey(liveRanges,i);
1656 /* mark these registers as used */
1657 for (k = 0 ; k < clr->nRegs ; k++ )
1658 useReg(clr->regs[k]);
1661 if (willCauseSpill(sym->nRegs,sym->regType)) {
1662 /* NOPE :( clear all registers & and continue */
1667 /* THERE IS HOPE !!!! */
1668 for (i=0; i < sym->nRegs ; i++ ) {
1669 if (sym->regType == REG_PTR)
1670 sym->regs[i] = getRegPtrNoSpil ();
1671 else if (sym->regType == REG_BIT)
1672 sym->regs[i] = getRegBitNoSpil ();
1674 sym->regs[i] = getRegGprNoSpil ();
1677 /* For all its definitions check if the registers
1678 allocated needs positioning NOTE: we can position
1679 only ONCE if more than One positioning required
1681 We may need to perform the checks twice; once to
1682 position the registers as needed, the second to
1683 verify any register repositioning is still
1687 for (pass=0; pass<2; pass++) {
1688 for (i = 0 ; i < sym->defs->size ; i++ ) {
1689 if (bitVectBitValue(sym->defs,i)) {
1691 if (!(ic = hTabItemWithKey(iCodehTab,i))) continue ;
1692 if (SKIP_IC(ic)) continue;
1693 assert(isSymbolEqual(sym,OP_SYMBOL(IC_RESULT(ic)))); /* just making sure */
1694 /* if left is assigned to registers */
1695 if (IS_SYMOP(IC_LEFT(ic)) &&
1696 bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_LEFT(ic))->key)) {
1697 pdone += (positionRegs(sym,OP_SYMBOL(IC_LEFT(ic)))>0);
1699 if (IS_SYMOP(IC_RIGHT(ic)) &&
1700 bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_RIGHT(ic))->key)) {
1701 pdone += (positionRegs(sym,OP_SYMBOL(IC_RIGHT(ic)))>0);
1703 if (pdone > 1) break;
1706 for (i = 0 ; i < sym->uses->size ; i++ ) {
1707 if (bitVectBitValue(sym->uses,i)) {
1709 if (!(ic = hTabItemWithKey(iCodehTab,i))) continue ;
1710 if (SKIP_IC(ic)) continue;
1711 if (POINTER_SET(ic) || POINTER_GET(ic)) continue ;
1713 /* if result is assigned to registers */
1714 if (IS_SYMOP(IC_RESULT(ic)) &&
1715 bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_RESULT(ic))->key)) {
1716 pdone += (positionRegs(sym,OP_SYMBOL(IC_RESULT(ic)))>0);
1718 if (pdone > 1) break;
1721 if (pdone == 0) break; /* second pass only if regs repositioned */
1722 if (pdone > 1) break;
1724 /* had to position more than once GIVE UP */
1726 /* UNDO all the changes we made to try this */
1728 for (i=0; i < sym->nRegs ; i++ ) {
1729 sym->regs[i] = NULL;
1732 D (fprintf (stderr, "Fill Gap gave up due to positioning for "
1733 "%s in function %s\n",
1734 sym->name, currFunc ? currFunc->name : "UNKNOWN"));
1737 D (fprintf (stderr, "FILLED GAP for %s in function %s\n",
1738 sym->name, currFunc ? currFunc->name : "UNKNOWN"));
1739 _G.totRegAssigned = bitVectSetBit(_G.totRegAssigned,sym->key);
1740 sym->isspilt = sym->spillA = 0 ;
1741 sym->usl.spillLoc->allocreq--;
1742 sym->usl.spillLoc = NULL;
1750 /*-----------------------------------------------------------------*/
1751 /* findAllBitregs :- returns bit vector of all bit registers */
1752 /*-----------------------------------------------------------------*/
1754 findAllBitregs (void)
1756 bitVect *rmask = newBitVect (ds390_nRegs);
1759 for (j = 0; j < ds390_nRegs; j++)
1761 if (regs390[j].type == REG_BIT)
1762 rmask = bitVectSetBit (rmask, regs390[j].rIdx);
1768 /*-----------------------------------------------------------------*/
1769 /* ds390_allBitregs :- returns bit vector of all bit registers */
1770 /*-----------------------------------------------------------------*/
1772 ds390_allBitregs (void)
1774 return _G.allBitregs;
1777 /*-----------------------------------------------------------------*/
1778 /* rUmaskForOp :- returns register mask for an operand */
1779 /*-----------------------------------------------------------------*/
1781 ds390_rUmaskForOp (operand * op)
1787 /* only temporaries are assigned registers */
1791 sym = OP_SYMBOL (op);
1793 /* if spilt or no registers assigned to it
1795 if (sym->isspilt || !sym->nRegs)
1798 rumask = newBitVect (ds390_nRegs);
1800 for (j = 0; j < sym->nRegs; j++)
1802 rumask = bitVectSetBit (rumask,
1803 sym->regs[j]->rIdx);
1809 /*-----------------------------------------------------------------*/
1810 /* regsUsedIniCode :- returns bit vector of registers used in iCode */
1811 /*-----------------------------------------------------------------*/
1813 regsUsedIniCode (iCode * ic)
1815 bitVect *rmask = newBitVect (ds390_nRegs);
1817 /* do the special cases first */
1820 rmask = bitVectUnion (rmask,
1821 ds390_rUmaskForOp (IC_COND (ic)));
1825 /* for the jumptable */
1826 if (ic->op == JUMPTABLE)
1828 rmask = bitVectUnion (rmask,
1829 ds390_rUmaskForOp (IC_JTCOND (ic)));
1834 /* of all other cases */
1836 rmask = bitVectUnion (rmask,
1837 ds390_rUmaskForOp (IC_LEFT (ic)));
1841 rmask = bitVectUnion (rmask,
1842 ds390_rUmaskForOp (IC_RIGHT (ic)));
1845 rmask = bitVectUnion (rmask,
1846 ds390_rUmaskForOp (IC_RESULT (ic)));
1852 /*-----------------------------------------------------------------*/
1853 /* createRegMask - for each instruction will determine the regsUsed */
1854 /*-----------------------------------------------------------------*/
1856 createRegMask (eBBlock ** ebbs, int count)
1860 /* for all blocks */
1861 for (i = 0; i < count; i++)
1865 if (ebbs[i]->noPath &&
1866 (ebbs[i]->entryLabel != entryLabel &&
1867 ebbs[i]->entryLabel != returnLabel))
1870 /* for all instructions */
1871 for (ic = ebbs[i]->sch; ic; ic = ic->next)
1876 if (SKIP_IC2 (ic) || !ic->rlive)
1879 /* first mark the registers used in this
1881 ic->rUsed = regsUsedIniCode (ic);
1882 _G.funcrUsed = bitVectUnion (_G.funcrUsed, ic->rUsed);
1884 /* now create the register mask for those
1885 registers that are in use : this is a
1886 super set of ic->rUsed */
1887 ic->rMask = newBitVect (ds390_nRegs + 1);
1889 /* for all live Ranges alive at this point */
1890 for (j = 1; j < ic->rlive->size; j++)
1895 /* if not alive then continue */
1896 if (!bitVectBitValue (ic->rlive, j))
1899 /* find the live range we are interested in */
1900 if (!(sym = hTabItemWithKey (liveRanges, j)))
1902 werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
1903 "createRegMask cannot find live range");
1904 fprintf(stderr, "\tmissing live range: key=%d\n", j);
1908 /* special case for ruonly */
1909 if (sym->ruonly && sym->liveFrom != sym->liveTo) {
1910 int size = getSize(sym->type);
1912 for (k = 0 ; k < size; k++ )
1913 ic->rMask = bitVectSetBit (ic->rMask, j++);
1917 /* if no register assigned to it */
1918 if (!sym->nRegs || sym->isspilt)
1921 /* for all the registers allocated to it */
1922 for (k = 0; k < sym->nRegs; k++)
1925 bitVectSetBit (ic->rMask, sym->regs[k]->rIdx);
1931 /*-----------------------------------------------------------------*/
1932 /* rematStr - returns the rematerialized string for a remat var */
1933 /*-----------------------------------------------------------------*/
1935 rematStr (symbol * sym)
1937 iCode *ic = sym->rematiCode;
1942 /* if plus adjust offset to right hand side */
1945 offset += (int) operandLitValue (IC_RIGHT (ic));
1946 ic = OP_SYMBOL (IC_LEFT (ic))->rematiCode;
1950 /* if minus adjust offset to right hand side */
1953 offset -= (int) operandLitValue (IC_RIGHT (ic));
1954 ic = OP_SYMBOL (IC_LEFT (ic))->rematiCode;
1958 /* cast then continue */
1959 if (IS_CAST_ICODE(ic)) {
1960 ic = OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
1963 /* we reached the end */
1969 SNPRINTF (buffer, sizeof(buffer),
1971 OP_SYMBOL (IC_LEFT (ic))->rname,
1972 offset >= 0 ? '+' : '-',
1973 abs (offset) & 0xffff);
1977 strncpyz (buffer, OP_SYMBOL (IC_LEFT (ic))->rname, sizeof(buffer));
1982 /*-----------------------------------------------------------------*/
1983 /* regTypeNum - computes the type & number of registers required */
1984 /*-----------------------------------------------------------------*/
1992 /* for each live range do */
1993 for (sym = hTabFirstItem (liveRanges, &k); sym;
1994 sym = hTabNextItem (liveRanges, &k))
1997 /* if used zero times then no registers needed */
1998 if ((sym->liveTo - sym->liveFrom) == 0)
2002 /* if the live range is a temporary */
2006 /* if the type is marked as a conditional */
2007 if (sym->regType == REG_CND)
2010 /* if used in return only then we don't
2012 if (sym->ruonly || sym->accuse)
2014 if (IS_AGGREGATE (sym->type) || sym->isptr)
2015 sym->type = aggrToPtr (sym->type, FALSE);
2019 /* if the symbol has only one definition &
2020 that definition is a get_pointer */
2021 if (bitVectnBitsOn (sym->defs) == 1 &&
2022 (ic = hTabItemWithKey (iCodehTab,
2023 bitVectFirstBit (sym->defs))) &&
2025 !IS_BITVAR (sym->etype) &&
2026 (aggrToPtrDclType (operandType (IC_LEFT (ic)), FALSE) == POINTER))
2029 if (ptrPseudoSymSafe (sym, ic))
2031 ptrPseudoSymConvert (sym, ic, rematStr (OP_SYMBOL (IC_LEFT (ic))));
2035 /* if in data space or idata space then try to
2036 allocate pointer register */
2040 /* if not then we require registers */
2041 sym->nRegs = ((IS_AGGREGATE (sym->type) || sym->isptr) ?
2042 getSize (sym->type = aggrToPtr (sym->type, FALSE)) :
2043 getSize (sym->type));
2047 fprintf (stderr, "allocated more than 4 or 0 registers for type ");
2048 printTypeChain (sym->type, stderr);
2049 fprintf (stderr, "\n");
2052 /* determine the type of register required */
2053 if (sym->nRegs == 1 && IS_PTR (sym->type) && sym->uptr)
2054 sym->regType = REG_PTR;
2055 else if (IS_BIT(sym->type))
2056 sym->regType = REG_BIT;
2058 sym->regType = REG_GPR;
2061 /* for the first run we don't provide */
2062 /* registers for true symbols we will */
2063 /* see how things go */
2069 /*-----------------------------------------------------------------*/
2070 /* freeAllRegs - mark all registers as free */
2071 /*-----------------------------------------------------------------*/
2077 for (i = 0; i < ds390_nRegs; i++)
2078 regs390[i].isFree = 1;
2080 for (i = B0_IDX; i < ds390_nBitRegs; i++)
2081 regs390[i].isFree = 1;
2084 /*-----------------------------------------------------------------*/
2085 /* deallocStackSpil - this will set the stack pointer back */
2086 /*-----------------------------------------------------------------*/
2088 DEFSETFUNC (deallocStackSpil)
2096 /*-----------------------------------------------------------------*/
2097 /* farSpacePackable - returns the packable icode for far variables */
2098 /*-----------------------------------------------------------------*/
2100 farSpacePackable (iCode * ic)
2104 /* go thru till we find a definition for the
2105 symbol on the right */
2106 for (dic = ic->prev; dic; dic = dic->prev)
2108 /* if the definition is a call then no */
2109 if ((dic->op == CALL || dic->op == PCALL) &&
2110 IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
2115 /* if shift by unknown amount then not */
2116 if ((dic->op == LEFT_OP || dic->op == RIGHT_OP) &&
2117 IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
2120 /* if pointer get and size > 1 */
2121 if (POINTER_GET (dic) &&
2122 getSize (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)) > 1)
2125 if (POINTER_SET (dic) &&
2126 getSize (aggrToPtr (operandType (IC_RESULT (dic)), FALSE)) > 1)
2129 /* if any tree is a true symbol in far space */
2130 if (IC_RESULT (dic) &&
2131 IS_TRUE_SYMOP (IC_RESULT (dic)) &&
2132 isOperandInFarSpace (IC_RESULT (dic)))
2135 if (IC_RIGHT (dic) &&
2136 IS_TRUE_SYMOP (IC_RIGHT (dic)) &&
2137 isOperandInFarSpace (IC_RIGHT (dic)) &&
2138 !isOperandEqual (IC_RIGHT (dic), IC_RESULT (ic)))
2141 if (IC_LEFT (dic) &&
2142 IS_TRUE_SYMOP (IC_LEFT (dic)) &&
2143 isOperandInFarSpace (IC_LEFT (dic)) &&
2144 !isOperandEqual (IC_LEFT (dic), IC_RESULT (ic)))
2147 if (isOperandEqual (IC_RIGHT (ic), IC_RESULT (dic)))
2149 if ((dic->op == LEFT_OP ||
2150 dic->op == RIGHT_OP ||
2152 IS_OP_LITERAL (IC_RIGHT (dic)))
2162 /*-----------------------------------------------------------------*/
2163 /* packRegsForAssign - register reduction for assignment */
2164 /*-----------------------------------------------------------------*/
2166 packRegsForAssign (iCode * ic, eBBlock * ebp)
2170 if (!IS_ITEMP (IC_RIGHT (ic)) ||
2171 OP_SYMBOL (IC_RIGHT (ic))->isind ||
2172 OP_LIVETO (IC_RIGHT (ic)) > ic->seq)
2177 /* if the true symbol is defined in far space or on stack
2178 then we should not since this will increase register pressure */
2180 if (isOperandInFarSpace (IC_RESULT (ic)))
2182 if ((dic = farSpacePackable (ic)))
2188 if (isOperandInFarSpace(IC_RESULT(ic)) && !farSpacePackable(ic)) {
2193 /* find the definition of iTempNN scanning backwards if we find a
2194 a use of the true symbol in before we find the definition then
2196 for (dic = ic->prev; dic; dic = dic->prev)
2198 /* if there is a function call then don't pack it */
2199 if ((dic->op == CALL || dic->op == PCALL))
2208 if (IS_TRUE_SYMOP (IC_RESULT (dic)) &&
2209 IS_OP_VOLATILE (IC_RESULT (dic)))
2215 if (IS_SYMOP (IC_RESULT (dic)) &&
2216 IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
2218 if (POINTER_SET (dic))
2224 if (IS_SYMOP (IC_RIGHT (dic)) &&
2225 (IC_RIGHT (dic)->key == IC_RESULT (ic)->key ||
2226 IC_RIGHT (dic)->key == IC_RIGHT (ic)->key))
2232 if (IS_SYMOP (IC_LEFT (dic)) &&
2233 (IC_LEFT (dic)->key == IC_RESULT (ic)->key ||
2234 IC_LEFT (dic)->key == IC_RIGHT (ic)->key))
2240 if (POINTER_SET (dic) &&
2241 IC_RESULT (dic)->key == IC_RESULT (ic)->key)
2249 return 0; /* did not find */
2251 /* if assignment then check that right is not a bit */
2252 if (ASSIGNMENT (ic) && !POINTER_SET (ic))
2254 sym_link *etype = operandType (IC_RESULT (dic));
2255 if (IS_BITFIELD (etype))
2257 /* if result is a bit too then it's ok */
2258 etype = operandType (IC_RESULT (ic));
2259 if (!IS_BITFIELD (etype))
2265 /* if the result is on stack or iaccess then it must be
2266 the same atleast one of the operands */
2267 if (OP_SYMBOL (IC_RESULT (ic))->onStack ||
2268 OP_SYMBOL (IC_RESULT (ic))->iaccess)
2271 /* the operation has only one symbol
2272 operator then we can pack */
2273 if ((IC_LEFT (dic) && !IS_SYMOP (IC_LEFT (dic))) ||
2274 (IC_RIGHT (dic) && !IS_SYMOP (IC_RIGHT (dic))))
2277 if (!((IC_LEFT (dic) &&
2278 IC_RESULT (ic)->key == IC_LEFT (dic)->key) ||
2280 IC_RESULT (ic)->key == IC_RIGHT (dic)->key)))
2284 /* found the definition */
2285 /* replace the result with the result of */
2286 /* this assignment and remove this assignment */
2287 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2289 IC_RESULT (dic) = IC_RESULT (ic);
2291 if (IS_ITEMP (IC_RESULT (dic)) && OP_SYMBOL (IC_RESULT (dic))->liveFrom > dic->seq)
2293 OP_SYMBOL (IC_RESULT (dic))->liveFrom = dic->seq;
2295 /* delete from liverange table also
2296 delete from all the points inbetween and the new
2298 for (sic = dic; sic != ic; sic = sic->next)
2300 bitVectUnSetBit (sic->rlive, IC_RESULT (ic)->key);
2301 if (IS_ITEMP (IC_RESULT (dic)))
2302 bitVectSetBit (sic->rlive, IC_RESULT (dic)->key);
2305 remiCodeFromeBBlock (ebp, ic);
2306 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
2307 hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
2308 OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
2312 /*------------------------------------------------------------------*/
2313 /* findAssignToSym : scanning backwards looks for first assig found */
2314 /*------------------------------------------------------------------*/
2316 findAssignToSym (operand * op, iCode * ic)
2320 /* This routine is used to find sequences like
2322 ...; (intervening ops don't use iTempAA or modify FOO)
2323 blah = blah + iTempAA;
2325 and eliminate the use of iTempAA, freeing up its register for
2329 for (dic = ic->prev; dic; dic = dic->prev)
2332 /* if definition by assignment */
2333 if (dic->op == '=' &&
2334 !POINTER_SET (dic) &&
2335 IC_RESULT (dic)->key == op->key
2336 /* && IS_TRUE_SYMOP(IC_RIGHT(dic)) */
2340 /* we are interested only if defined in far space */
2341 /* or in stack space in case of + & - */
2343 /* if assigned to a non-symbol then return
2345 if (!IS_SYMOP (IC_RIGHT (dic)))
2348 /* if the symbol is in far space then we should not */
2349 if (isOperandInFarSpace (IC_RIGHT (dic)))
2352 /* for + & - operations make sure that
2353 if it is on the stack it is the same
2354 as one of the three operands */
2355 if ((ic->op == '+' || ic->op == '-') &&
2356 OP_SYMBOL (IC_RIGHT (dic))->onStack)
2359 if (IC_RESULT (ic)->key != IC_RIGHT (dic)->key &&
2360 IC_LEFT (ic)->key != IC_RIGHT (dic)->key &&
2361 IC_RIGHT (ic)->key != IC_RIGHT (dic)->key)
2369 /* if we find an usage then we cannot delete it */
2370 if (IC_LEFT (dic) && IC_LEFT (dic)->key == op->key)
2373 if (IC_RIGHT (dic) && IC_RIGHT (dic)->key == op->key)
2376 if (POINTER_SET (dic) && IC_RESULT (dic)->key == op->key)
2380 /* now make sure that the right side of dic
2381 is not defined between ic & dic */
2384 iCode *sic = dic->next;
2386 for (; sic != ic; sic = sic->next)
2387 if (IC_RESULT (sic) &&
2388 IC_RESULT (sic)->key == IC_RIGHT (dic)->key)
2397 /*-----------------------------------------------------------------*/
2398 /* packRegsForSupport :- reduce some registers for support calls */
2399 /*-----------------------------------------------------------------*/
2401 packRegsForSupport (iCode * ic, eBBlock * ebp)
2405 /* for the left & right operand :- look to see if the
2406 left was assigned a true symbol in far space in that
2407 case replace them */
2408 if (IS_ITEMP (IC_LEFT (ic)) &&
2409 OP_SYMBOL (IC_LEFT (ic))->liveTo <= ic->seq)
2411 iCode *dic = findAssignToSym (IC_LEFT (ic), ic);
2417 /* found it we need to remove it from the
2419 for (sic = dic; sic != ic; sic = sic->next) {
2420 bitVectUnSetBit (sic->rlive, IC_LEFT (ic)->key);
2421 sic->rlive = bitVectSetBit (sic->rlive, IC_RIGHT (dic)->key);
2424 wassert(IS_SYMOP(IC_LEFT (ic)));
2425 wassert(IS_SYMOP(IC_RIGHT (dic)));
2426 IC_LEFT (ic)->operand.symOperand =
2427 IC_RIGHT (dic)->operand.symOperand;
2428 OP_SYMBOL(IC_LEFT(ic))->liveTo = ic->seq;
2429 IC_LEFT (ic)->key = IC_RIGHT (dic)->operand.symOperand->key;
2430 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2431 remiCodeFromeBBlock (ebp, dic);
2432 hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2436 /* do the same for the right operand */
2439 IS_ITEMP (IC_RIGHT (ic)) &&
2440 OP_SYMBOL (IC_RIGHT (ic))->liveTo <= ic->seq)
2442 iCode *dic = findAssignToSym (IC_RIGHT (ic), ic);
2448 /* if this is a subtraction & the result
2449 is a true symbol in far space then don't pack */
2450 if (ic->op == '-' && IS_TRUE_SYMOP (IC_RESULT (dic)))
2452 sym_link *etype = getSpec (operandType (IC_RESULT (dic)));
2453 if (IN_FARSPACE (SPEC_OCLS (etype)))
2456 /* found it we need to remove it from the
2458 for (sic = dic; sic != ic; sic = sic->next) {
2459 bitVectUnSetBit (sic->rlive, IC_RIGHT (ic)->key);
2460 sic->rlive = bitVectSetBit (sic->rlive, IC_RIGHT (dic)->key);
2463 wassert(IS_SYMOP(IC_RIGHT (ic)));
2464 wassert(IS_SYMOP(IC_RIGHT (dic)));
2465 IC_RIGHT (ic)->operand.symOperand =
2466 IC_RIGHT (dic)->operand.symOperand;
2467 IC_RIGHT (ic)->key = IC_RIGHT (dic)->operand.symOperand->key;
2468 OP_SYMBOL(IC_RIGHT(ic))->liveTo = ic->seq;
2469 remiCodeFromeBBlock (ebp, dic);
2470 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2471 hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2478 #define IS_OP_RUONLY(x) (x && IS_SYMOP(x) && OP_SYMBOL(x)->ruonly)
2481 /*-----------------------------------------------------------------*/
2482 /* packRegsDPTRnuse - color live ranges that can go into extra DPTRS */
2483 /*-----------------------------------------------------------------*/
2484 static int packRegsDPTRnuse( operand *op , unsigned dptr)
2489 if (!IS_SYMOP(op) || !IS_ITEMP(op)) return 0;
2490 if (OP_SYMBOL(op)->remat || OP_SYMBOL(op)->ruonly || OP_SYMBOL(op)->dptr)
2493 /* first check if any overlapping liverange has already been
2494 assigned to this DPTR */
2495 if (OP_SYMBOL(op)->clashes) {
2496 for (i = 0 ; i < OP_SYMBOL(op)->clashes->size ; i++ ) {
2498 if (bitVectBitValue(OP_SYMBOL(op)->clashes,i)) {
2499 sym = hTabItemWithKey(liveRanges,i);
2500 if (sym->dptr == dptr) return 0;
2505 /* future for more dptrs */
2507 OP_SYMBOL(op)->dptr = dptr;
2511 /* DPTR1 is special since it is also used as a scratch by the backend .
2512 so we walk thru the entire live range of this operand and make sure
2513 DPTR1 will not be used by the backed . The logic here is to find out if
2514 more than one operand in an icode is in far space then we give up : we
2515 don't keep it live across functions for now
2518 ic = hTabFirstItemWK(iCodeSeqhTab,OP_SYMBOL(op)->liveFrom);
2519 for (; ic && ic->seq <= OP_SYMBOL(op)->liveTo;
2520 ic = hTabNextItem(iCodeSeqhTab,&key)) {
2523 if (ic->op == CALL || ic->op == PCALL) return 0;
2525 /* single operand icode are ok */
2526 if (ic->op == IFX || ic->op == IPUSH)
2529 if (ic->op == SEND ) {
2530 if (ic->argreg != 1 ) return 0;
2533 /* two special cases first */
2534 if (POINTER_GET(ic) && !isOperandEqual(IC_LEFT(ic),op) && /* pointer get */
2535 !OP_SYMBOL(IC_LEFT(ic))->ruonly && /* with result in far space */
2536 (isOperandInFarSpace(IC_RESULT(ic)) &&
2537 !isOperandInReg(IC_RESULT(ic)))) {
2541 if (POINTER_SET(ic) && !isOperandEqual(IC_RESULT(ic),op) && /* pointer set */
2542 !OP_SYMBOL(IC_RESULT(ic))->ruonly && /* with right in far space */
2543 (isOperandInFarSpace(IC_RIGHT(ic)) &&
2544 !isOperandInReg(IC_RIGHT(ic)))) {
2548 if (IC_RESULT(ic) && IS_SYMOP(IC_RESULT(ic)) && /* if symbol operand */
2549 !isOperandEqual(IC_RESULT(ic),op) && /* not the same as this */
2550 ((isOperandInFarSpace(IC_RESULT(ic)) || /* in farspace or */
2551 OP_SYMBOL(IC_RESULT(ic))->onStack) && /* on the stack */
2552 !isOperandInReg(IC_RESULT(ic)))) { /* and not in register */
2556 if (IC_LEFT(ic) && IS_SYMOP(IC_LEFT(ic)) && /* if symbol operand */
2557 !isOperandEqual(IC_LEFT(ic),op) && /* not the same as this */
2558 ((isOperandInFarSpace(IC_LEFT(ic)) || /* in farspace or */
2559 OP_SYMBOL(IC_LEFT(ic))->onStack) && /* on the stack */
2560 !isOperandInReg(IC_LEFT(ic)))) { /* and not in register */
2563 /* same for right */
2564 if (IC_RIGHT(ic) && IS_SYMOP(IC_RIGHT(ic)) && /* if symbol operand */
2565 !isOperandEqual(IC_RIGHT(ic),op) && /* not the same as this */
2566 ((isOperandInFarSpace(IC_RIGHT(ic)) || /* in farspace or */
2567 OP_SYMBOL(IC_RIGHT(ic))->onStack) && /* on the stack */
2568 !isOperandInReg(IC_RIGHT(ic)))) { /* and not in register */
2572 // Check that no other ops in this range have been assigned to dptr1.
2573 // I don't understand why this is not caught by the first check, above.
2574 // But it isn't always, see bug 769624.
2575 if (IC_RESULT(ic) && IS_SYMOP(IC_RESULT(ic)) &&
2576 (OP_SYMBOL(IC_RESULT(ic))->dptr == 1))
2578 //fprintf(stderr, "dptr1 already in use in live range #1\n");
2582 if (IC_LEFT(ic) && IS_SYMOP(IC_LEFT(ic)) &&
2583 (OP_SYMBOL(IC_LEFT(ic))->dptr == 1))
2585 //fprintf(stderr, "dptr1 already in use in live range # 2\n");
2589 if (IC_RIGHT(ic) && IS_SYMOP(IC_RIGHT(ic)) &&
2590 (OP_SYMBOL(IC_RIGHT(ic))->dptr == 1))
2592 //fprintf(stderr, "dptr1 already in use in live range # 3\n");
2596 if (nfs && IC_RESULT(ic) && IS_SYMOP(IC_RESULT(ic)) &&
2597 OP_SYMBOL(IC_RESULT(ic))->ruonly) return 0;
2599 if (nfs > 1) return 0;
2601 OP_SYMBOL(op)->dptr = dptr;
2605 /*-----------------------------------------------------------------*/
2606 /* packRegsDPTRuse : - will reduce some registers for single Use */
2607 /*-----------------------------------------------------------------*/
2609 packRegsDPTRuse (operand * op)
2611 /* go thru entire liveRange of this variable & check for
2612 other possible usage of DPTR , if we don't find it the
2613 assign this to DPTR (ruonly)
2618 sym_link *type, *etype;
2620 if (!IS_SYMOP(op) || !IS_ITEMP(op)) return NULL;
2621 if (OP_SYMBOL(op)->remat || OP_SYMBOL(op)->ruonly) return NULL;
2623 /* first check if any overlapping liverange has already been
2625 if (OP_SYMBOL(op)->clashes) {
2626 for (i = 0 ; i < OP_SYMBOL(op)->clashes->size ; i++ ) {
2627 if (bitVectBitValue(OP_SYMBOL(op)->clashes,i)) {
2628 sym = hTabItemWithKey(liveRanges,i);
2629 if (sym->ruonly) return NULL ;
2634 /* no then go thru this guys live range */
2635 dic = ic = hTabFirstItemWK(iCodeSeqhTab,OP_SYMBOL(op)->liveFrom);
2636 for (; ic && ic->seq <= OP_SYMBOL(op)->liveTo;
2637 ic = hTabNextItem(iCodeSeqhTab,&key)) {
2639 if (SKIP_IC3(ic)) continue;
2641 /* if PCALL cannot be sure give up */
2642 if (ic->op == PCALL) return NULL;
2644 /* if SEND & not the first parameter then giveup */
2645 if (ic->op == SEND && ic->argreg != 1 &&
2646 ((isOperandInFarSpace(IC_LEFT(ic)) && !isOperandInReg(IC_LEFT(ic))) ||
2647 isOperandEqual(op,IC_LEFT(ic)))) return NULL;
2649 /* if CALL then make sure it is VOID || return value not used
2650 or the return value is assigned to this one */
2651 if (ic->op == CALL) {
2652 if (OP_SYMBOL(IC_RESULT(ic))->liveTo ==
2653 OP_SYMBOL(IC_RESULT(ic))->liveFrom) continue ;
2654 etype = getSpec(type = operandType(IC_RESULT(ic)));
2655 if (getSize(type) == 0 || isOperandEqual(op,IC_RESULT(ic)))
2660 /* special case of add with a [remat] */
2661 if (ic->op == '+' &&
2662 OP_SYMBOL(IC_LEFT(ic))->remat &&
2663 (isOperandInFarSpace(IC_RIGHT(ic)) &&
2664 !isOperandInReg(IC_RIGHT(ic)))) return NULL ;
2668 if (POINTER_GET(ic) && !isOperandEqual(IC_LEFT(ic),op) &&
2669 getSize(operandType(IC_LEFT(ic))) > 1 ) return NULL ;
2672 if (POINTER_SET(ic) && !isOperandEqual(IC_RESULT(ic),op) &&
2673 getSize(operandType(IC_RESULT(ic))) > 1 ) return NULL;
2675 /* conditionals can destroy 'b' - make sure B wont
2676 be used in this one*/
2677 if ((IS_CONDITIONAL(ic) || ic->op == '*' || ic->op == '/' ||
2678 ic->op == LEFT_OP || ic->op == RIGHT_OP ) &&
2679 getSize(operandType(op)) > 3) return NULL;
2681 /* if this is a cast to a bigger type */
2683 if (!IS_PTR(OP_SYM_TYPE(IC_RESULT(ic))) &&
2684 getSize(OP_SYM_TYPE(IC_RESULT(ic))) >
2685 getSize(OP_SYM_TYPE(IC_RIGHT(ic)))) {
2691 if (IC_RESULT(ic) && IS_SYMOP(IC_RESULT(ic)) &&
2692 !isOperandEqual(IC_RESULT(ic),op) &&
2693 ( ( ( isOperandInFarSpace(IC_RESULT(ic)) || OP_SYMBOL(IC_RESULT(ic))->onStack) &&
2694 !isOperandInReg(IC_RESULT(ic))) ||
2695 OP_SYMBOL(IC_RESULT(ic))->ruonly)) return NULL;
2697 if (IC_RIGHT(ic) && IS_SYMOP(IC_RIGHT(ic)) &&
2698 !isOperandEqual(IC_RIGHT(ic),op) &&
2699 (OP_SYMBOL(IC_RIGHT(ic))->liveTo >= ic->seq ||
2700 IS_TRUE_SYMOP(IC_RIGHT(ic)) ||
2701 OP_SYMBOL(IC_RIGHT(ic))->ruonly) &&
2702 ( ( isOperandInFarSpace(IC_RIGHT(ic)) || OP_SYMBOL(IC_RIGHT(ic))->onStack) &&
2703 !isOperandInReg(IC_RIGHT(ic))) ) return NULL;
2705 if (IC_LEFT(ic) && IS_SYMOP(IC_LEFT(ic)) &&
2706 !isOperandEqual(IC_LEFT(ic),op) &&
2707 (OP_SYMBOL(IC_LEFT(ic))->liveTo >= ic->seq ||
2708 IS_TRUE_SYMOP(IC_LEFT(ic)) ||
2709 OP_SYMBOL(IC_LEFT(ic))->ruonly) &&
2710 ( ( isOperandInFarSpace(IC_LEFT(ic)) || OP_SYMBOL(IC_LEFT(ic))->onStack) &&
2711 !isOperandInReg(IC_LEFT(ic))) ) return NULL;
2713 if (IC_LEFT(ic) && IC_RIGHT(ic) &&
2714 IS_ITEMP(IC_LEFT(ic)) && IS_ITEMP(IC_RIGHT(ic)) &&
2715 (isOperandInFarSpace(IC_LEFT(ic)) && !isOperandInReg(IC_LEFT(ic))) &&
2716 (isOperandInFarSpace(IC_RIGHT(ic)) && !isOperandInReg(IC_RIGHT(ic))))
2719 OP_SYMBOL(op)->ruonly = 1;
2720 if (OP_SYMBOL(op)->usl.spillLoc) {
2721 if (OP_SYMBOL(op)->spillA)
2722 OP_SYMBOL(op)->usl.spillLoc->allocreq--;
2723 OP_SYMBOL(op)->usl.spillLoc = NULL;
2728 /*-----------------------------------------------------------------*/
2729 /* isBitwiseOptimizable - requirements of JEAN LOUIS VERN */
2730 /*-----------------------------------------------------------------*/
2732 isBitwiseOptimizable (iCode * ic)
2734 sym_link *ltype = getSpec (operandType (IC_LEFT (ic)));
2735 sym_link *rtype = getSpec (operandType (IC_RIGHT (ic)));
2737 /* bitwise operations are considered optimizable
2738 under the following conditions (Jean-Louis VERN)
2750 if (IS_LITERAL (rtype) ||
2751 (IS_BITVAR (ltype) && IN_BITSPACE (SPEC_OCLS (ltype))))
2757 /*-----------------------------------------------------------------*/
2758 /* packRegsForAccUse - pack registers for acc use */
2759 /*-----------------------------------------------------------------*/
2761 packRegsForAccUse (iCode * ic)
2765 /* if this is an aggregate, e.g. a one byte char array */
2766 if (IS_AGGREGATE(operandType(IC_RESULT(ic)))) {
2770 /* if we are calling a reentrant function that has stack parameters */
2771 if (ic->op == CALL &&
2772 IFFUNC_ISREENT(operandType(IC_LEFT(ic))) &&
2773 FUNC_HASSTACKPARM(operandType(IC_LEFT(ic))))
2776 if (ic->op == PCALL &&
2777 IFFUNC_ISREENT(operandType(IC_LEFT(ic))->next) &&
2778 FUNC_HASSTACKPARM(operandType(IC_LEFT(ic))->next))
2781 /* if + or - then it has to be one byte result */
2782 if ((ic->op == '+' || ic->op == '-')
2783 && getSize (operandType (IC_RESULT (ic))) > 1)
2786 /* if shift operation make sure right side is not a literal */
2787 if (ic->op == RIGHT_OP &&
2788 (isOperandLiteral (IC_RIGHT (ic)) ||
2789 getSize (operandType (IC_RESULT (ic))) > 1))
2792 if (ic->op == LEFT_OP &&
2793 (isOperandLiteral (IC_RIGHT (ic)) ||
2794 getSize (operandType (IC_RESULT (ic))) > 1))
2797 if (IS_BITWISE_OP (ic) &&
2798 getSize (operandType (IC_RESULT (ic))) > 1)
2802 /* has only one definition */
2803 if (bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) > 1)
2806 /* has only one use */
2807 if (bitVectnBitsOn (OP_USES (IC_RESULT (ic))) > 1)
2810 /* and the usage immediately follows this iCode */
2811 if (!(uic = hTabItemWithKey (iCodehTab,
2812 bitVectFirstBit (OP_USES (IC_RESULT (ic))))))
2815 if (ic->next != uic)
2818 /* if it is a conditional branch then we definitely can */
2822 if (uic->op == JUMPTABLE)
2825 /* if the usage is not is an assignment
2826 or an arithmetic / bitwise / shift operation then not */
2827 if (POINTER_SET (uic) &&
2828 getSize (aggrToPtr (operandType (IC_RESULT (uic)), FALSE)) > 1)
2831 if (uic->op != '=' &&
2832 !IS_ARITHMETIC_OP (uic) &&
2833 !IS_BITWISE_OP (uic) &&
2834 uic->op != LEFT_OP &&
2835 uic->op != RIGHT_OP)
2838 /* if used in ^ operation then make sure right is not a
2840 if (uic->op == '^' && isOperandLiteral (IC_RIGHT (uic)))
2843 /* if shift operation make sure right side is not a literal */
2844 if (uic->op == RIGHT_OP &&
2845 (isOperandLiteral (IC_RIGHT (uic)) ||
2846 getSize (operandType (IC_RESULT (uic))) > 1))
2849 if (uic->op == LEFT_OP &&
2850 (isOperandLiteral (IC_RIGHT (uic)) ||
2851 getSize (operandType (IC_RESULT (uic))) > 1))
2854 /* make sure that the result of this icode is not on the
2855 stack, since acc is used to compute stack offset */
2856 if (isOperandOnStack(IC_RESULT(uic)))
2859 /* if either one of them in far space then we cannot */
2860 if ((IS_TRUE_SYMOP (IC_LEFT (uic)) &&
2861 isOperandInFarSpace (IC_LEFT (uic))) ||
2862 (IS_TRUE_SYMOP (IC_RIGHT (uic)) &&
2863 isOperandInFarSpace (IC_RIGHT (uic))))
2866 /* if the usage has only one operand then we can */
2867 if (IC_LEFT (uic) == NULL ||
2868 IC_RIGHT (uic) == NULL)
2871 /* make sure this is on the left side if not
2872 a '+' since '+' is commutative */
2873 if (ic->op != '+' &&
2874 IC_LEFT (uic)->key != IC_RESULT (ic)->key)
2877 /* if the other one is not on stack then we can */
2878 if (IC_LEFT (uic)->key == IC_RESULT (ic)->key &&
2879 (IS_ITEMP (IC_RIGHT (uic)) ||
2880 (IS_TRUE_SYMOP (IC_RIGHT (uic)) &&
2881 !OP_SYMBOL (IC_RIGHT (uic))->onStack)))
2884 if (IC_RIGHT (uic)->key == IC_RESULT (ic)->key &&
2885 (IS_ITEMP (IC_LEFT (uic)) ||
2886 (IS_TRUE_SYMOP (IC_LEFT (uic)) &&
2887 !OP_SYMBOL (IC_LEFT (uic))->onStack)))
2893 OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
2897 /*-----------------------------------------------------------------*/
2898 /* packForPush - heuristics to reduce iCode for pushing */
2899 /*-----------------------------------------------------------------*/
2901 packForPush (iCode * ic, eBBlock ** ebpp, int blockno)
2905 struct eBBlock * ebp = ebpp[blockno];
2907 if ((ic->op != IPUSH && ic->op != SEND) || !IS_ITEMP (IC_LEFT (ic)))
2910 /* must have only definition & one usage */
2911 if (bitVectnBitsOn (OP_DEFS (IC_LEFT (ic))) != 1 ||
2912 bitVectnBitsOn (OP_USES (IC_LEFT (ic))) != 1)
2915 /* find the definition */
2916 if (!(dic = hTabItemWithKey (iCodehTab,
2917 bitVectFirstBit (OP_DEFS (IC_LEFT (ic))))))
2920 if (dic->op != '=' || POINTER_SET (dic))
2923 if (dic->eBBlockNum != ic->eBBlockNum) return ;
2925 /* make sure the right side does not have any definitions
2927 dbv = OP_DEFS(IC_RIGHT(dic));
2928 for (lic = ic; lic && lic != dic ; lic = lic->prev) {
2929 if (bitVectBitValue (dbv, lic->key))
2932 /* make sure they have the same type */
2933 if (IS_SPEC(operandType(IC_LEFT(ic))))
2935 sym_link *itype=operandType(IC_LEFT(ic));
2936 sym_link *ditype=operandType(IC_RIGHT(dic));
2938 if (SPEC_USIGN(itype)!=SPEC_USIGN(ditype) ||
2939 SPEC_LONG(itype)!=SPEC_LONG(ditype))
2942 /* extend the live range of replaced operand if needed */
2943 if (OP_SYMBOL(IC_RIGHT(dic))->liveTo < OP_SYMBOL(IC_LEFT(ic))->liveTo) {
2944 OP_SYMBOL(IC_RIGHT(dic))->liveTo = OP_SYMBOL(IC_LEFT(ic))->liveTo;
2945 OP_SYMBOL(IC_RIGHT(dic))->clashes =
2946 bitVectUnion(OP_SYMBOL(IC_RIGHT(dic))->clashes,
2947 OP_SYMBOL(IC_LEFT(ic))->clashes);
2949 for (lic = ic; lic && lic != dic; lic = lic->prev)
2951 bitVectUnSetBit (lic->rlive, IC_LEFT (ic)->key);
2952 if (IS_ITEMP (IC_RIGHT (dic)))
2953 bitVectSetBit (lic->rlive, IC_RIGHT (dic)->key);
2955 /* we now we know that it has one & only one def & use
2956 and the that the definition is an assignment */
2957 IC_LEFT (ic) = IC_RIGHT (dic);
2959 remiCodeFromeBBlock (ebp, dic);
2960 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2961 hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2964 /*-----------------------------------------------------------------*/
2965 /* packRegisters - does some transformations to reduce register */
2967 /*-----------------------------------------------------------------*/
2969 packRegisters (eBBlock ** ebpp, int blockno)
2973 eBBlock *ebp = ebpp[blockno];
2979 /* look for assignments of the form */
2980 /* iTempNN = TRueSym (someoperation) SomeOperand */
2982 /* TrueSym := iTempNN:1 */
2983 for (ic = ebp->sch; ic; ic = ic->next)
2985 /* find assignment of the form TrueSym := iTempNN:1 */
2986 if (ic->op == '=' && !POINTER_SET (ic))
2987 change += packRegsForAssign (ic, ebp);
2994 for (ic = ebp->sch; ic; ic = ic->next)
2996 /* Fix for bug #979599: */
2999 /* Look for two subsequent iCodes with */
3001 /* _c = iTemp & op; */
3002 /* and replace them by */
3005 if ((ic->op == BITWISEAND || ic->op == '|' || ic->op == '^') &&
3007 ic->prev->op == '=' &&
3008 IS_ITEMP (IC_LEFT (ic)) &&
3009 IC_LEFT (ic) == IC_RESULT (ic->prev) &&
3010 isOperandEqual (IC_RESULT(ic), IC_RIGHT(ic->prev)))
3012 iCode* ic_prev = ic->prev;
3013 symbol* prev_result_sym = OP_SYMBOL (IC_RESULT (ic_prev));
3015 ReplaceOpWithCheaperOp (&IC_LEFT (ic), IC_RESULT (ic));
3016 if (IC_RESULT (ic_prev) != IC_RIGHT (ic))
3018 bitVectUnSetBit (OP_USES (IC_RESULT (ic_prev)), ic->key);
3019 if (/*IS_ITEMP (IC_RESULT (ic_prev)) && */
3020 prev_result_sym->liveTo == ic->seq)
3022 prev_result_sym->liveTo = ic_prev->seq;
3025 bitVectSetBit (OP_USES (IC_RESULT (ic)), ic->key);
3027 bitVectSetBit (ic->rlive, IC_RESULT (ic)->key);
3029 if (bitVectIsZero (OP_USES (IC_RESULT (ic_prev))))
3031 bitVectUnSetBit (ic->rlive, IC_RESULT (ic)->key);
3032 bitVectUnSetBit (OP_DEFS (IC_RESULT (ic_prev)), ic_prev->key);
3033 remiCodeFromeBBlock (ebp, ic_prev);
3034 hTabDeleteItem (&iCodehTab, ic_prev->key, ic_prev, DELETE_ITEM, NULL);
3038 /* if this is an itemp & result of an address of a true sym
3039 then mark this as rematerialisable */
3040 if (ic->op == ADDRESS_OF &&
3041 IS_ITEMP (IC_RESULT (ic)) &&
3042 IS_TRUE_SYMOP (IC_LEFT (ic)) &&
3043 bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
3044 !OP_SYMBOL (IC_LEFT (ic))->onStack)
3047 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
3048 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
3049 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
3053 /* if this is an itemp & used as a pointer
3054 & assigned to a literal then remat */
3055 if (IS_ASSIGN_ICODE(ic) &&
3056 IS_ITEMP(IC_RESULT(ic)) &&
3057 bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
3058 isOperandLiteral(IC_RIGHT(ic)))
3060 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
3061 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
3062 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
3065 /* if straight assignment then carry remat flag if
3066 this is the only definition */
3067 if (ic->op == '=' &&
3068 !POINTER_SET (ic) &&
3069 IS_SYMOP (IC_RIGHT (ic)) &&
3070 OP_SYMBOL (IC_RIGHT (ic))->remat &&
3071 !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode) &&
3072 bitVectnBitsOn (OP_SYMBOL (IC_RESULT (ic))->defs) <= 1)
3074 OP_SYMBOL (IC_RESULT (ic))->remat =
3075 OP_SYMBOL (IC_RIGHT (ic))->remat;
3076 OP_SYMBOL (IC_RESULT (ic))->rematiCode =
3077 OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
3080 /* if cast to a generic pointer & the pointer being
3081 cast is remat, then we can remat this cast as well */
3082 if (ic->op == CAST &&
3083 IS_SYMOP(IC_RIGHT(ic)) &&
3084 !OP_SYMBOL(IC_RESULT(ic))->isreqv &&
3085 OP_SYMBOL(IC_RIGHT(ic))->remat )
3087 sym_link *to_type = operandType(IC_LEFT(ic));
3088 sym_link *from_type = operandType(IC_RIGHT(ic));
3089 if (IS_GENPTR(to_type) && IS_PTR(from_type))
3091 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
3092 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
3093 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
3097 /* if this is a +/- operation with a rematerizable
3098 then mark this as rematerializable as well */
3099 if ((ic->op == '+' || ic->op == '-') &&
3100 (IS_SYMOP (IC_LEFT (ic)) &&
3101 IS_ITEMP (IC_RESULT (ic)) &&
3102 OP_SYMBOL (IC_LEFT (ic))->remat &&
3103 (!IS_SYMOP (IC_RIGHT (ic)) || !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode)) &&
3104 bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
3105 IS_OP_LITERAL (IC_RIGHT (ic))))
3108 //int i = operandLitValue(IC_RIGHT(ic));
3109 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
3110 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
3111 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
3114 /* mark the pointer usages */
3115 if (POINTER_SET (ic) && IS_SYMOP (IC_RESULT (ic)))
3116 OP_SYMBOL (IC_RESULT (ic))->uptr = 1;
3118 if (POINTER_GET (ic) && IS_SYMOP (IC_LEFT (ic)))
3119 OP_SYMBOL (IC_LEFT (ic))->uptr = 1;
3121 if (ic->op == RETURN && IS_SYMOP (IC_LEFT(ic)))
3122 OP_SYMBOL (IC_LEFT (ic))->uptr = 1;
3124 if (ic->op == RECEIVE && ic->argreg == 1 &&
3125 IS_SYMOP (IC_RESULT (ic)) &&
3126 getSize (operandType(IC_RESULT(ic))) <= 3)
3127 OP_SYMBOL (IC_RESULT(ic))->uptr = 1;
3129 if (ic->op == SEND && ic->argreg == 1 &&
3130 IS_SYMOP(IC_LEFT(ic)) &&
3131 getSize (aggrToPtr(operandType(IC_LEFT(ic)),FALSE)) <= 3)
3132 OP_SYMBOL (IC_LEFT(ic))->uptr = 1;
3136 /* if we are using a symbol on the stack
3137 then we should say ds390_ptrRegReq */
3138 if (options.useXstack && ic->parmPush
3139 && (ic->op == IPUSH || ic->op == IPOP))
3141 if (ic->op == IFX && IS_SYMOP (IC_COND (ic)))
3142 ds390_ptrRegReq += ((OP_SYMBOL (IC_COND (ic))->onStack ? !options.stack10bit : 0) +
3143 OP_SYMBOL (IC_COND (ic))->iaccess +
3144 (SPEC_OCLS(OP_SYMBOL (IC_COND (ic))->etype) == idata));
3145 else if (ic->op == JUMPTABLE && IS_SYMOP (IC_JTCOND (ic)))
3146 ds390_ptrRegReq += ((OP_SYMBOL (IC_JTCOND (ic))->onStack ? !options.stack10bit : 0) +
3147 OP_SYMBOL (IC_JTCOND (ic))->iaccess +
3148 (SPEC_OCLS(OP_SYMBOL (IC_JTCOND (ic))->etype) == idata));
3151 if (IS_SYMOP (IC_LEFT (ic)))
3152 ds390_ptrRegReq += ((OP_SYMBOL (IC_LEFT (ic))->onStack ? !options.stack10bit : 0) +
3153 OP_SYMBOL (IC_LEFT (ic))->iaccess +
3154 (SPEC_OCLS(OP_SYMBOL (IC_LEFT (ic))->etype) == idata));
3155 if (IS_SYMOP (IC_RIGHT (ic)))
3156 ds390_ptrRegReq += ((OP_SYMBOL (IC_RIGHT (ic))->onStack ? !options.stack10bit : 0) +
3157 OP_SYMBOL (IC_RIGHT (ic))->iaccess +
3158 (SPEC_OCLS(OP_SYMBOL (IC_RIGHT (ic))->etype) == idata));
3159 if (IS_SYMOP (IC_RESULT (ic)))
3160 ds390_ptrRegReq += ((OP_SYMBOL (IC_RESULT (ic))->onStack ? !options.stack10bit : 0) +
3161 OP_SYMBOL (IC_RESULT (ic))->iaccess +
3162 (SPEC_OCLS(OP_SYMBOL (IC_RESULT (ic))->etype) == idata));
3166 /* if the condition of an if instruction
3167 is defined in the previous instruction and
3168 this is the only usage then
3169 mark the itemp as a conditional */
3170 if ((IS_CONDITIONAL (ic) ||
3171 (IS_BITWISE_OP(ic) && isBitwiseOptimizable (ic))) &&
3172 ic->next && ic->next->op == IFX &&
3173 bitVectnBitsOn (OP_USES(IC_RESULT(ic)))==1 &&
3174 isOperandEqual (IC_RESULT (ic), IC_COND (ic->next)) &&
3175 OP_SYMBOL (IC_RESULT (ic))->liveTo <= ic->next->seq)
3177 OP_SYMBOL (IC_RESULT (ic))->regType = REG_CND;
3181 /* reduce for support function calls */
3182 if (ic->supportRtn || ic->op == '+' || ic->op == '-')
3183 packRegsForSupport (ic, ebp);
3185 /* some cases the redundant moves can
3186 can be eliminated for return statements . Can be elminated for the first SEND */
3187 if ((ic->op == RETURN ||
3188 ((ic->op == SEND || ic->op == RECEIVE)&& ic->argreg == 1)) &&
3189 !isOperandInFarSpace (IC_LEFT (ic)) &&
3192 packRegsDPTRuse (IC_LEFT (ic));
3195 if (ic->op == CALL) {
3196 sym_link *ftype = operandType(IC_LEFT(ic));
3197 if (getSize(operandType(IC_RESULT(ic))) <= 4 &&
3198 !IFFUNC_ISBUILTIN(ftype)) {
3199 packRegsDPTRuse (IC_RESULT (ic));
3203 /* if pointer set & left has a size more than
3204 one and right is not in far space */
3205 if (POINTER_SET (ic) &&
3206 !isOperandInFarSpace (IC_RIGHT (ic)) &&
3207 IS_SYMOP (IC_RESULT (ic)) &&
3208 !OP_SYMBOL (IC_RESULT (ic))->remat &&
3209 !IS_OP_RUONLY (IC_RIGHT (ic)) &&
3210 getSize (aggrToPtr (operandType (IC_RESULT (ic)), FALSE)) > 1) {
3212 packRegsDPTRuse (IC_RESULT (ic));
3215 /* if pointer get */
3216 if (POINTER_GET (ic) &&
3217 !isOperandInFarSpace (IC_RESULT (ic)) &&
3218 IS_SYMOP (IC_LEFT (ic)) &&
3219 !OP_SYMBOL (IC_LEFT (ic))->remat &&
3220 !IS_OP_RUONLY (IC_RESULT (ic)) &&
3221 getSize (aggrToPtr (operandType (IC_LEFT (ic)), FALSE)) > 1) {
3223 packRegsDPTRuse (IC_LEFT (ic));
3226 /* if this is a cast for intergral promotion then
3227 check if it's the only use of the definition of the
3228 operand being casted/ if yes then replace
3229 the result of that arithmetic operation with
3230 this result and get rid of the cast */
3233 sym_link *fromType = operandType (IC_RIGHT (ic));
3234 sym_link *toType = operandType (IC_LEFT (ic));
3236 if (IS_INTEGRAL (fromType) && IS_INTEGRAL (toType) &&
3237 getSize (fromType) != getSize (toType) &&
3238 SPEC_USIGN (fromType) == SPEC_USIGN (toType))
3241 iCode *dic = packRegsDPTRuse (IC_RIGHT (ic));
3244 if (IS_ARITHMETIC_OP (dic))
3246 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
3247 IC_RESULT (dic) = IC_RESULT (ic);
3248 remiCodeFromeBBlock (ebp, ic);
3249 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
3250 hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
3251 OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
3255 OP_SYMBOL (IC_RIGHT (ic))->ruonly = 0;
3261 /* if the type from and type to are the same
3262 then if this is the only use then packit */
3263 if (compareType (operandType (IC_RIGHT (ic)),
3264 operandType (IC_LEFT (ic))) == 1)
3266 iCode *dic = packRegsDPTRuse (IC_RIGHT (ic));
3269 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
3270 IC_RESULT (dic) = IC_RESULT (ic);
3271 remiCodeFromeBBlock (ebp, ic);
3272 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
3273 hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
3274 OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
3282 iTempNN := (some variable in farspace) V1
3287 if (ic->op == IPUSH || ic->op == SEND)
3289 packForPush (ic, ebpp, blockno);
3293 /* pack registers for accumulator use, when the
3294 result of an arithmetic or bit wise operation
3295 has only one use, that use is immediately following
3296 the defintion and the using iCode has only one
3297 operand or has two operands but one is literal &
3298 the result of that operation is not on stack then
3299 we can leave the result of this operation in acc:b
3301 if ((IS_ARITHMETIC_OP (ic)
3302 || IS_CONDITIONAL(ic)
3303 || IS_BITWISE_OP (ic)
3304 || ic->op == LEFT_OP || ic->op == RIGHT_OP
3305 || (ic->op == ADDRESS_OF && isOperandOnStack (IC_LEFT (ic)))
3307 IS_ITEMP (IC_RESULT (ic)) &&
3308 getSize (operandType (IC_RESULT (ic))) <= 2)
3310 packRegsForAccUse (ic);
3314 /*-----------------------------------------------------------------*/
3315 /* assignRegisters - assigns registers to each live range as need */
3316 /*-----------------------------------------------------------------*/
3318 ds390_assignRegisters (ebbIndex * ebbi)
3320 eBBlock ** ebbs = ebbi->bbOrder;
3321 int count = ebbi->count;
3325 setToNull ((void *) &_G.funcrUsed);
3326 setToNull ((void *) &_G.regAssigned);
3327 setToNull ((void *) &_G.totRegAssigned);
3328 setToNull ((void *) &_G.funcrUsed);
3329 ds390_ptrRegReq = _G.stackExtend = _G.dataExtend = 0;
3330 if ((currFunc && IFFUNC_ISREENT (currFunc->type)) || options.stackAuto)
3338 ds390_nRegs = 12 + ds390_nBitRegs;
3339 _G.allBitregs = findAllBitregs ();
3341 if (options.model != MODEL_FLAT24)
3342 options.stack10bit = 0;
3343 /* change assignments this will remove some
3344 live ranges reducing some register pressure */
3345 for (i = 0; i < count; i++)
3346 packRegisters (ebbs, i);
3348 /* liveranges probably changed by register packing
3349 so we compute them again */
3350 recomputeLiveRanges (ebbs, count);
3352 if (options.dump_pack)
3353 dumpEbbsToFileExt (DUMP_PACK, ebbi);
3355 /* first determine for each live range the number of
3356 registers & the type of registers required for each */
3359 /* and serially allocate registers */
3360 serialRegAssign (ebbs, count);
3365 ds390_nRegs = 12 + ds390_nBitRegs;
3367 /* if stack was extended then tell the user */
3370 /* werror(W_TOOMANY_SPILS,"stack", */
3371 /* _G.stackExtend,currFunc->name,""); */
3377 /* werror(W_TOOMANY_SPILS,"data space", */
3378 /* _G.dataExtend,currFunc->name,""); */
3382 /* after that create the register mask
3383 for each of the instruction */
3384 createRegMask (ebbs, count);
3386 /* redo that offsets for stacked automatic variables */
3388 redoStackOffsets ();
3390 /* make sure r0 & r1 are flagged as used if they might be used */
3392 if (currFunc && ds390_ptrRegReq)
3394 currFunc->regsUsed = bitVectSetBit (currFunc->regsUsed, R0_IDX);
3395 currFunc->regsUsed = bitVectSetBit (currFunc->regsUsed, R1_IDX);
3398 if (options.dump_rassgn)
3400 dumpEbbsToFileExt (DUMP_RASSGN, ebbi);
3401 dumpLiveRanges (DUMP_LRANGE, liveRanges);
3404 /* do the overlaysegment stuff SDCCmem.c */
3405 doOverlays (ebbs, count);
3407 /* now get back the chain */
3408 ic = iCodeLabelOptimize (iCodeFromeBBlock (ebbs, count));
3412 /* free up any _G.stackSpil locations allocated */
3413 applyToSet (_G.stackSpil, deallocStackSpil);
3415 setToNull ((void *) &_G.stackSpil);
3416 setToNull ((void *) &_G.spiltSet);
3417 /* mark all registers as free */