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)
1938 iCode *ic = sym->rematiCode;
1945 /* if plus or minus print the right hand side */
1946 if (ic->op == '+' || ic->op == '-')
1948 SNPRINTF (s, sizeof(buffer) - strlen(buffer),
1949 "0x%04x %c ", (int) operandLitValue (IC_RIGHT (ic)),
1952 ic = OP_SYMBOL (IC_LEFT (ic))->rematiCode;
1956 /* cast then continue */
1957 if (IS_CAST_ICODE(ic)) {
1958 ic = OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
1961 /* we reached the end */
1962 SNPRINTF (s, sizeof(buffer) - strlen(buffer),
1963 "%s", OP_SYMBOL (IC_LEFT (ic))->rname);
1970 /*-----------------------------------------------------------------*/
1971 /* regTypeNum - computes the type & number of registers required */
1972 /*-----------------------------------------------------------------*/
1980 /* for each live range do */
1981 for (sym = hTabFirstItem (liveRanges, &k); sym;
1982 sym = hTabNextItem (liveRanges, &k))
1985 /* if used zero times then no registers needed */
1986 if ((sym->liveTo - sym->liveFrom) == 0)
1990 /* if the live range is a temporary */
1994 /* if the type is marked as a conditional */
1995 if (sym->regType == REG_CND)
1998 /* if used in return only then we don't
2000 if (sym->ruonly || sym->accuse)
2002 if (IS_AGGREGATE (sym->type) || sym->isptr)
2003 sym->type = aggrToPtr (sym->type, FALSE);
2007 /* if the symbol has only one definition &
2008 that definition is a get_pointer */
2009 if (bitVectnBitsOn (sym->defs) == 1 &&
2010 (ic = hTabItemWithKey (iCodehTab,
2011 bitVectFirstBit (sym->defs))) &&
2013 !IS_BITVAR (sym->etype) &&
2014 (aggrToPtrDclType (operandType (IC_LEFT (ic)), FALSE) == POINTER))
2017 if (ptrPseudoSymSafe (sym, ic))
2019 ptrPseudoSymConvert (sym, ic, rematStr (OP_SYMBOL (IC_LEFT (ic))));
2023 /* if in data space or idata space then try to
2024 allocate pointer register */
2028 /* if not then we require registers */
2029 sym->nRegs = ((IS_AGGREGATE (sym->type) || sym->isptr) ?
2030 getSize (sym->type = aggrToPtr (sym->type, FALSE)) :
2031 getSize (sym->type));
2035 fprintf (stderr, "allocated more than 4 or 0 registers for type ");
2036 printTypeChain (sym->type, stderr);
2037 fprintf (stderr, "\n");
2040 /* determine the type of register required */
2041 if (sym->nRegs == 1 && IS_PTR (sym->type) && sym->uptr)
2042 sym->regType = REG_PTR;
2043 else if (IS_BIT(sym->type))
2044 sym->regType = REG_BIT;
2046 sym->regType = REG_GPR;
2049 /* for the first run we don't provide */
2050 /* registers for true symbols we will */
2051 /* see how things go */
2057 /*-----------------------------------------------------------------*/
2058 /* freeAllRegs - mark all registers as free */
2059 /*-----------------------------------------------------------------*/
2065 for (i = 0; i < ds390_nRegs; i++)
2066 regs390[i].isFree = 1;
2068 for (i = B0_IDX; i < ds390_nBitRegs; i++)
2069 regs390[i].isFree = 1;
2072 /*-----------------------------------------------------------------*/
2073 /* deallocStackSpil - this will set the stack pointer back */
2074 /*-----------------------------------------------------------------*/
2076 DEFSETFUNC (deallocStackSpil)
2084 /*-----------------------------------------------------------------*/
2085 /* farSpacePackable - returns the packable icode for far variables */
2086 /*-----------------------------------------------------------------*/
2088 farSpacePackable (iCode * ic)
2092 /* go thru till we find a definition for the
2093 symbol on the right */
2094 for (dic = ic->prev; dic; dic = dic->prev)
2096 /* if the definition is a call then no */
2097 if ((dic->op == CALL || dic->op == PCALL) &&
2098 IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
2103 /* if shift by unknown amount then not */
2104 if ((dic->op == LEFT_OP || dic->op == RIGHT_OP) &&
2105 IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
2108 /* if pointer get and size > 1 */
2109 if (POINTER_GET (dic) &&
2110 getSize (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)) > 1)
2113 if (POINTER_SET (dic) &&
2114 getSize (aggrToPtr (operandType (IC_RESULT (dic)), FALSE)) > 1)
2117 /* if any tree is a true symbol in far space */
2118 if (IC_RESULT (dic) &&
2119 IS_TRUE_SYMOP (IC_RESULT (dic)) &&
2120 isOperandInFarSpace (IC_RESULT (dic)))
2123 if (IC_RIGHT (dic) &&
2124 IS_TRUE_SYMOP (IC_RIGHT (dic)) &&
2125 isOperandInFarSpace (IC_RIGHT (dic)) &&
2126 !isOperandEqual (IC_RIGHT (dic), IC_RESULT (ic)))
2129 if (IC_LEFT (dic) &&
2130 IS_TRUE_SYMOP (IC_LEFT (dic)) &&
2131 isOperandInFarSpace (IC_LEFT (dic)) &&
2132 !isOperandEqual (IC_LEFT (dic), IC_RESULT (ic)))
2135 if (isOperandEqual (IC_RIGHT (ic), IC_RESULT (dic)))
2137 if ((dic->op == LEFT_OP ||
2138 dic->op == RIGHT_OP ||
2140 IS_OP_LITERAL (IC_RIGHT (dic)))
2150 /*-----------------------------------------------------------------*/
2151 /* packRegsForAssign - register reduction for assignment */
2152 /*-----------------------------------------------------------------*/
2154 packRegsForAssign (iCode * ic, eBBlock * ebp)
2158 if (!IS_ITEMP (IC_RIGHT (ic)) ||
2159 OP_SYMBOL (IC_RIGHT (ic))->isind ||
2160 OP_LIVETO (IC_RIGHT (ic)) > ic->seq)
2165 /* if the true symbol is defined in far space or on stack
2166 then we should not since this will increase register pressure */
2168 if (isOperandInFarSpace (IC_RESULT (ic)))
2170 if ((dic = farSpacePackable (ic)))
2176 if (isOperandInFarSpace(IC_RESULT(ic)) && !farSpacePackable(ic)) {
2181 /* find the definition of iTempNN scanning backwards if we find a
2182 a use of the true symbol in before we find the definition then
2184 for (dic = ic->prev; dic; dic = dic->prev)
2186 /* if there is a function call then don't pack it */
2187 if ((dic->op == CALL || dic->op == PCALL))
2196 if (IS_TRUE_SYMOP (IC_RESULT (dic)) &&
2197 IS_OP_VOLATILE (IC_RESULT (dic)))
2203 if (IS_SYMOP (IC_RESULT (dic)) &&
2204 IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
2206 if (POINTER_SET (dic))
2212 if (IS_SYMOP (IC_RIGHT (dic)) &&
2213 (IC_RIGHT (dic)->key == IC_RESULT (ic)->key ||
2214 IC_RIGHT (dic)->key == IC_RIGHT (ic)->key))
2220 if (IS_SYMOP (IC_LEFT (dic)) &&
2221 (IC_LEFT (dic)->key == IC_RESULT (ic)->key ||
2222 IC_LEFT (dic)->key == IC_RIGHT (ic)->key))
2228 if (POINTER_SET (dic) &&
2229 IC_RESULT (dic)->key == IC_RESULT (ic)->key)
2237 return 0; /* did not find */
2239 /* if assignment then check that right is not a bit */
2240 if (ASSIGNMENT (ic) && !POINTER_SET (ic))
2242 sym_link *etype = operandType (IC_RESULT (dic));
2243 if (IS_BITFIELD (etype))
2245 /* if result is a bit too then it's ok */
2246 etype = operandType (IC_RESULT (ic));
2247 if (!IS_BITFIELD (etype))
2253 /* if the result is on stack or iaccess then it must be
2254 the same atleast one of the operands */
2255 if (OP_SYMBOL (IC_RESULT (ic))->onStack ||
2256 OP_SYMBOL (IC_RESULT (ic))->iaccess)
2259 /* the operation has only one symbol
2260 operator then we can pack */
2261 if ((IC_LEFT (dic) && !IS_SYMOP (IC_LEFT (dic))) ||
2262 (IC_RIGHT (dic) && !IS_SYMOP (IC_RIGHT (dic))))
2265 if (!((IC_LEFT (dic) &&
2266 IC_RESULT (ic)->key == IC_LEFT (dic)->key) ||
2268 IC_RESULT (ic)->key == IC_RIGHT (dic)->key)))
2272 /* found the definition */
2273 /* replace the result with the result of */
2274 /* this assignment and remove this assignment */
2275 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2277 IC_RESULT (dic) = IC_RESULT (ic);
2279 if (IS_ITEMP (IC_RESULT (dic)) && OP_SYMBOL (IC_RESULT (dic))->liveFrom > dic->seq)
2281 OP_SYMBOL (IC_RESULT (dic))->liveFrom = dic->seq;
2283 /* delete from liverange table also
2284 delete from all the points inbetween and the new
2286 for (sic = dic; sic != ic; sic = sic->next)
2288 bitVectUnSetBit (sic->rlive, IC_RESULT (ic)->key);
2289 if (IS_ITEMP (IC_RESULT (dic)))
2290 bitVectSetBit (sic->rlive, IC_RESULT (dic)->key);
2293 remiCodeFromeBBlock (ebp, ic);
2294 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
2295 hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
2296 OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
2300 /*------------------------------------------------------------------*/
2301 /* findAssignToSym : scanning backwards looks for first assig found */
2302 /*------------------------------------------------------------------*/
2304 findAssignToSym (operand * op, iCode * ic)
2308 /* This routine is used to find sequences like
2310 ...; (intervening ops don't use iTempAA or modify FOO)
2311 blah = blah + iTempAA;
2313 and eliminate the use of iTempAA, freeing up its register for
2317 for (dic = ic->prev; dic; dic = dic->prev)
2320 /* if definition by assignment */
2321 if (dic->op == '=' &&
2322 !POINTER_SET (dic) &&
2323 IC_RESULT (dic)->key == op->key
2324 /* && IS_TRUE_SYMOP(IC_RIGHT(dic)) */
2328 /* we are interested only if defined in far space */
2329 /* or in stack space in case of + & - */
2331 /* if assigned to a non-symbol then return
2333 if (!IS_SYMOP (IC_RIGHT (dic)))
2336 /* if the symbol is in far space then we should not */
2337 if (isOperandInFarSpace (IC_RIGHT (dic)))
2340 /* for + & - operations make sure that
2341 if it is on the stack it is the same
2342 as one of the three operands */
2343 if ((ic->op == '+' || ic->op == '-') &&
2344 OP_SYMBOL (IC_RIGHT (dic))->onStack)
2347 if (IC_RESULT (ic)->key != IC_RIGHT (dic)->key &&
2348 IC_LEFT (ic)->key != IC_RIGHT (dic)->key &&
2349 IC_RIGHT (ic)->key != IC_RIGHT (dic)->key)
2357 /* if we find an usage then we cannot delete it */
2358 if (IC_LEFT (dic) && IC_LEFT (dic)->key == op->key)
2361 if (IC_RIGHT (dic) && IC_RIGHT (dic)->key == op->key)
2364 if (POINTER_SET (dic) && IC_RESULT (dic)->key == op->key)
2368 /* now make sure that the right side of dic
2369 is not defined between ic & dic */
2372 iCode *sic = dic->next;
2374 for (; sic != ic; sic = sic->next)
2375 if (IC_RESULT (sic) &&
2376 IC_RESULT (sic)->key == IC_RIGHT (dic)->key)
2385 /*-----------------------------------------------------------------*/
2386 /* packRegsForSupport :- reduce some registers for support calls */
2387 /*-----------------------------------------------------------------*/
2389 packRegsForSupport (iCode * ic, eBBlock * ebp)
2393 /* for the left & right operand :- look to see if the
2394 left was assigned a true symbol in far space in that
2395 case replace them */
2396 if (IS_ITEMP (IC_LEFT (ic)) &&
2397 OP_SYMBOL (IC_LEFT (ic))->liveTo <= ic->seq)
2399 iCode *dic = findAssignToSym (IC_LEFT (ic), ic);
2405 /* found it we need to remove it from the
2407 for (sic = dic; sic != ic; sic = sic->next) {
2408 bitVectUnSetBit (sic->rlive, IC_LEFT (ic)->key);
2409 sic->rlive = bitVectSetBit (sic->rlive, IC_RIGHT (dic)->key);
2412 wassert(IS_SYMOP(IC_LEFT (ic)));
2413 wassert(IS_SYMOP(IC_RIGHT (dic)));
2414 IC_LEFT (ic)->operand.symOperand =
2415 IC_RIGHT (dic)->operand.symOperand;
2416 OP_SYMBOL(IC_LEFT(ic))->liveTo = ic->seq;
2417 IC_LEFT (ic)->key = IC_RIGHT (dic)->operand.symOperand->key;
2418 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2419 remiCodeFromeBBlock (ebp, dic);
2420 hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2424 /* do the same for the right operand */
2427 IS_ITEMP (IC_RIGHT (ic)) &&
2428 OP_SYMBOL (IC_RIGHT (ic))->liveTo <= ic->seq)
2430 iCode *dic = findAssignToSym (IC_RIGHT (ic), ic);
2436 /* if this is a subtraction & the result
2437 is a true symbol in far space then don't pack */
2438 if (ic->op == '-' && IS_TRUE_SYMOP (IC_RESULT (dic)))
2440 sym_link *etype = getSpec (operandType (IC_RESULT (dic)));
2441 if (IN_FARSPACE (SPEC_OCLS (etype)))
2444 /* found it we need to remove it from the
2446 for (sic = dic; sic != ic; sic = sic->next) {
2447 bitVectUnSetBit (sic->rlive, IC_RIGHT (ic)->key);
2448 sic->rlive = bitVectSetBit (sic->rlive, IC_RIGHT (dic)->key);
2451 wassert(IS_SYMOP(IC_RIGHT (ic)));
2452 wassert(IS_SYMOP(IC_RIGHT (dic)));
2453 IC_RIGHT (ic)->operand.symOperand =
2454 IC_RIGHT (dic)->operand.symOperand;
2455 IC_RIGHT (ic)->key = IC_RIGHT (dic)->operand.symOperand->key;
2456 OP_SYMBOL(IC_RIGHT(ic))->liveTo = ic->seq;
2457 remiCodeFromeBBlock (ebp, dic);
2458 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2459 hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2466 #define IS_OP_RUONLY(x) (x && IS_SYMOP(x) && OP_SYMBOL(x)->ruonly)
2469 /*-----------------------------------------------------------------*/
2470 /* packRegsDPTRnuse - color live ranges that can go into extra DPTRS */
2471 /*-----------------------------------------------------------------*/
2472 static int packRegsDPTRnuse( operand *op , unsigned dptr)
2477 if (!IS_SYMOP(op) || !IS_ITEMP(op)) return 0;
2478 if (OP_SYMBOL(op)->remat || OP_SYMBOL(op)->ruonly || OP_SYMBOL(op)->dptr)
2481 /* first check if any overlapping liverange has already been
2482 assigned to this DPTR */
2483 if (OP_SYMBOL(op)->clashes) {
2484 for (i = 0 ; i < OP_SYMBOL(op)->clashes->size ; i++ ) {
2486 if (bitVectBitValue(OP_SYMBOL(op)->clashes,i)) {
2487 sym = hTabItemWithKey(liveRanges,i);
2488 if (sym->dptr == dptr) return 0;
2493 /* future for more dptrs */
2495 OP_SYMBOL(op)->dptr = dptr;
2499 /* DPTR1 is special since it is also used as a scratch by the backend .
2500 so we walk thru the entire live range of this operand and make sure
2501 DPTR1 will not be used by the backed . The logic here is to find out if
2502 more than one operand in an icode is in far space then we give up : we
2503 don't keep it live across functions for now
2506 ic = hTabFirstItemWK(iCodeSeqhTab,OP_SYMBOL(op)->liveFrom);
2507 for (; ic && ic->seq <= OP_SYMBOL(op)->liveTo;
2508 ic = hTabNextItem(iCodeSeqhTab,&key)) {
2511 if (ic->op == CALL || ic->op == PCALL) return 0;
2513 /* single operand icode are ok */
2514 if (ic->op == IFX || ic->op == IPUSH)
2517 if (ic->op == SEND ) {
2518 if (ic->argreg != 1 ) return 0;
2521 /* two special cases first */
2522 if (POINTER_GET(ic) && !isOperandEqual(IC_LEFT(ic),op) && /* pointer get */
2523 !OP_SYMBOL(IC_LEFT(ic))->ruonly && /* with result in far space */
2524 (isOperandInFarSpace(IC_RESULT(ic)) &&
2525 !isOperandInReg(IC_RESULT(ic)))) {
2529 if (POINTER_SET(ic) && !isOperandEqual(IC_RESULT(ic),op) && /* pointer set */
2530 !OP_SYMBOL(IC_RESULT(ic))->ruonly && /* with right in far space */
2531 (isOperandInFarSpace(IC_RIGHT(ic)) &&
2532 !isOperandInReg(IC_RIGHT(ic)))) {
2536 if (IC_RESULT(ic) && IS_SYMOP(IC_RESULT(ic)) && /* if symbol operand */
2537 !isOperandEqual(IC_RESULT(ic),op) && /* not the same as this */
2538 ((isOperandInFarSpace(IC_RESULT(ic)) || /* in farspace or */
2539 OP_SYMBOL(IC_RESULT(ic))->onStack) && /* on the stack */
2540 !isOperandInReg(IC_RESULT(ic)))) { /* and not in register */
2544 if (IC_LEFT(ic) && IS_SYMOP(IC_LEFT(ic)) && /* if symbol operand */
2545 !isOperandEqual(IC_LEFT(ic),op) && /* not the same as this */
2546 ((isOperandInFarSpace(IC_LEFT(ic)) || /* in farspace or */
2547 OP_SYMBOL(IC_LEFT(ic))->onStack) && /* on the stack */
2548 !isOperandInReg(IC_LEFT(ic)))) { /* and not in register */
2551 /* same for right */
2552 if (IC_RIGHT(ic) && IS_SYMOP(IC_RIGHT(ic)) && /* if symbol operand */
2553 !isOperandEqual(IC_RIGHT(ic),op) && /* not the same as this */
2554 ((isOperandInFarSpace(IC_RIGHT(ic)) || /* in farspace or */
2555 OP_SYMBOL(IC_RIGHT(ic))->onStack) && /* on the stack */
2556 !isOperandInReg(IC_RIGHT(ic)))) { /* and not in register */
2560 // Check that no other ops in this range have been assigned to dptr1.
2561 // I don't understand why this is not caught by the first check, above.
2562 // But it isn't always, see bug 769624.
2563 if (IC_RESULT(ic) && IS_SYMOP(IC_RESULT(ic)) &&
2564 (OP_SYMBOL(IC_RESULT(ic))->dptr == 1))
2566 //fprintf(stderr, "dptr1 already in use in live range #1\n");
2570 if (IC_LEFT(ic) && IS_SYMOP(IC_LEFT(ic)) &&
2571 (OP_SYMBOL(IC_LEFT(ic))->dptr == 1))
2573 //fprintf(stderr, "dptr1 already in use in live range # 2\n");
2577 if (IC_RIGHT(ic) && IS_SYMOP(IC_RIGHT(ic)) &&
2578 (OP_SYMBOL(IC_RIGHT(ic))->dptr == 1))
2580 //fprintf(stderr, "dptr1 already in use in live range # 3\n");
2584 if (nfs && IC_RESULT(ic) && IS_SYMOP(IC_RESULT(ic)) &&
2585 OP_SYMBOL(IC_RESULT(ic))->ruonly) return 0;
2587 if (nfs > 1) return 0;
2589 OP_SYMBOL(op)->dptr = dptr;
2593 /*-----------------------------------------------------------------*/
2594 /* packRegsDPTRuse : - will reduce some registers for single Use */
2595 /*-----------------------------------------------------------------*/
2597 packRegsDPTRuse (operand * op)
2599 /* go thru entire liveRange of this variable & check for
2600 other possible usage of DPTR , if we don't find it the
2601 assign this to DPTR (ruonly)
2606 sym_link *type, *etype;
2608 if (!IS_SYMOP(op) || !IS_ITEMP(op)) return NULL;
2609 if (OP_SYMBOL(op)->remat || OP_SYMBOL(op)->ruonly) return NULL;
2611 /* first check if any overlapping liverange has already been
2613 if (OP_SYMBOL(op)->clashes) {
2614 for (i = 0 ; i < OP_SYMBOL(op)->clashes->size ; i++ ) {
2615 if (bitVectBitValue(OP_SYMBOL(op)->clashes,i)) {
2616 sym = hTabItemWithKey(liveRanges,i);
2617 if (sym->ruonly) return NULL ;
2622 /* no then go thru this guys live range */
2623 dic = ic = hTabFirstItemWK(iCodeSeqhTab,OP_SYMBOL(op)->liveFrom);
2624 for (; ic && ic->seq <= OP_SYMBOL(op)->liveTo;
2625 ic = hTabNextItem(iCodeSeqhTab,&key)) {
2627 if (SKIP_IC3(ic)) continue;
2629 /* if PCALL cannot be sure give up */
2630 if (ic->op == PCALL) return NULL;
2632 /* if SEND & not the first parameter then giveup */
2633 if (ic->op == SEND && ic->argreg != 1 &&
2634 ((isOperandInFarSpace(IC_LEFT(ic)) && !isOperandInReg(IC_LEFT(ic))) ||
2635 isOperandEqual(op,IC_LEFT(ic)))) return NULL;
2637 /* if CALL then make sure it is VOID || return value not used
2638 or the return value is assigned to this one */
2639 if (ic->op == CALL) {
2640 if (OP_SYMBOL(IC_RESULT(ic))->liveTo ==
2641 OP_SYMBOL(IC_RESULT(ic))->liveFrom) continue ;
2642 etype = getSpec(type = operandType(IC_RESULT(ic)));
2643 if (getSize(type) == 0 || isOperandEqual(op,IC_RESULT(ic)))
2648 /* special case of add with a [remat] */
2649 if (ic->op == '+' &&
2650 OP_SYMBOL(IC_LEFT(ic))->remat &&
2651 (isOperandInFarSpace(IC_RIGHT(ic)) &&
2652 !isOperandInReg(IC_RIGHT(ic)))) return NULL ;
2656 if (POINTER_GET(ic) && !isOperandEqual(IC_LEFT(ic),op) &&
2657 getSize(operandType(IC_LEFT(ic))) > 1 ) return NULL ;
2660 if (POINTER_SET(ic) && !isOperandEqual(IC_RESULT(ic),op) &&
2661 getSize(operandType(IC_RESULT(ic))) > 1 ) return NULL;
2663 /* conditionals can destroy 'b' - make sure B wont
2664 be used in this one*/
2665 if ((IS_CONDITIONAL(ic) || ic->op == '*' || ic->op == '/' ||
2666 ic->op == LEFT_OP || ic->op == RIGHT_OP ) &&
2667 getSize(operandType(op)) > 3) return NULL;
2669 /* if this is a cast to a bigger type */
2671 if (!IS_PTR(OP_SYM_TYPE(IC_RESULT(ic))) &&
2672 getSize(OP_SYM_TYPE(IC_RESULT(ic))) >
2673 getSize(OP_SYM_TYPE(IC_RIGHT(ic)))) {
2679 if (IC_RESULT(ic) && IS_SYMOP(IC_RESULT(ic)) &&
2680 !isOperandEqual(IC_RESULT(ic),op) &&
2681 ( ( ( isOperandInFarSpace(IC_RESULT(ic)) || OP_SYMBOL(IC_RESULT(ic))->onStack) &&
2682 !isOperandInReg(IC_RESULT(ic))) ||
2683 OP_SYMBOL(IC_RESULT(ic))->ruonly)) return NULL;
2685 if (IC_RIGHT(ic) && IS_SYMOP(IC_RIGHT(ic)) &&
2686 !isOperandEqual(IC_RIGHT(ic),op) &&
2687 (OP_SYMBOL(IC_RIGHT(ic))->liveTo >= ic->seq ||
2688 IS_TRUE_SYMOP(IC_RIGHT(ic)) ||
2689 OP_SYMBOL(IC_RIGHT(ic))->ruonly) &&
2690 ( ( isOperandInFarSpace(IC_RIGHT(ic)) || OP_SYMBOL(IC_RIGHT(ic))->onStack) &&
2691 !isOperandInReg(IC_RIGHT(ic))) ) return NULL;
2693 if (IC_LEFT(ic) && IS_SYMOP(IC_LEFT(ic)) &&
2694 !isOperandEqual(IC_LEFT(ic),op) &&
2695 (OP_SYMBOL(IC_LEFT(ic))->liveTo >= ic->seq ||
2696 IS_TRUE_SYMOP(IC_LEFT(ic)) ||
2697 OP_SYMBOL(IC_LEFT(ic))->ruonly) &&
2698 ( ( isOperandInFarSpace(IC_LEFT(ic)) || OP_SYMBOL(IC_LEFT(ic))->onStack) &&
2699 !isOperandInReg(IC_LEFT(ic))) ) return NULL;
2701 if (IC_LEFT(ic) && IC_RIGHT(ic) &&
2702 IS_ITEMP(IC_LEFT(ic)) && IS_ITEMP(IC_RIGHT(ic)) &&
2703 (isOperandInFarSpace(IC_LEFT(ic)) && !isOperandInReg(IC_LEFT(ic))) &&
2704 (isOperandInFarSpace(IC_RIGHT(ic)) && !isOperandInReg(IC_RIGHT(ic))))
2707 OP_SYMBOL(op)->ruonly = 1;
2708 if (OP_SYMBOL(op)->usl.spillLoc) {
2709 if (OP_SYMBOL(op)->spillA)
2710 OP_SYMBOL(op)->usl.spillLoc->allocreq--;
2711 OP_SYMBOL(op)->usl.spillLoc = NULL;
2716 /*-----------------------------------------------------------------*/
2717 /* isBitwiseOptimizable - requirements of JEAN LOUIS VERN */
2718 /*-----------------------------------------------------------------*/
2720 isBitwiseOptimizable (iCode * ic)
2722 sym_link *ltype = getSpec (operandType (IC_LEFT (ic)));
2723 sym_link *rtype = getSpec (operandType (IC_RIGHT (ic)));
2725 /* bitwise operations are considered optimizable
2726 under the following conditions (Jean-Louis VERN)
2738 if (IS_LITERAL (rtype) ||
2739 (IS_BITVAR (ltype) && IN_BITSPACE (SPEC_OCLS (ltype))))
2745 /*-----------------------------------------------------------------*/
2746 /* packRegsForAccUse - pack registers for acc use */
2747 /*-----------------------------------------------------------------*/
2749 packRegsForAccUse (iCode * ic)
2753 /* if this is an aggregate, e.g. a one byte char array */
2754 if (IS_AGGREGATE(operandType(IC_RESULT(ic)))) {
2758 /* if we are calling a reentrant function that has stack parameters */
2759 if (ic->op == CALL &&
2760 IFFUNC_ISREENT(operandType(IC_LEFT(ic))) &&
2761 FUNC_HASSTACKPARM(operandType(IC_LEFT(ic))))
2764 if (ic->op == PCALL &&
2765 IFFUNC_ISREENT(operandType(IC_LEFT(ic))->next) &&
2766 FUNC_HASSTACKPARM(operandType(IC_LEFT(ic))->next))
2769 /* if + or - then it has to be one byte result */
2770 if ((ic->op == '+' || ic->op == '-')
2771 && getSize (operandType (IC_RESULT (ic))) > 1)
2774 /* if shift operation make sure right side is not a literal */
2775 if (ic->op == RIGHT_OP &&
2776 (isOperandLiteral (IC_RIGHT (ic)) ||
2777 getSize (operandType (IC_RESULT (ic))) > 1))
2780 if (ic->op == LEFT_OP &&
2781 (isOperandLiteral (IC_RIGHT (ic)) ||
2782 getSize (operandType (IC_RESULT (ic))) > 1))
2785 if (IS_BITWISE_OP (ic) &&
2786 getSize (operandType (IC_RESULT (ic))) > 1)
2790 /* has only one definition */
2791 if (bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) > 1)
2794 /* has only one use */
2795 if (bitVectnBitsOn (OP_USES (IC_RESULT (ic))) > 1)
2798 /* and the usage immediately follows this iCode */
2799 if (!(uic = hTabItemWithKey (iCodehTab,
2800 bitVectFirstBit (OP_USES (IC_RESULT (ic))))))
2803 if (ic->next != uic)
2806 /* if it is a conditional branch then we definitely can */
2810 if (uic->op == JUMPTABLE)
2813 /* if the usage is not is an assignment
2814 or an arithmetic / bitwise / shift operation then not */
2815 if (POINTER_SET (uic) &&
2816 getSize (aggrToPtr (operandType (IC_RESULT (uic)), FALSE)) > 1)
2819 if (uic->op != '=' &&
2820 !IS_ARITHMETIC_OP (uic) &&
2821 !IS_BITWISE_OP (uic) &&
2822 uic->op != LEFT_OP &&
2823 uic->op != RIGHT_OP)
2826 /* if used in ^ operation then make sure right is not a
2828 if (uic->op == '^' && isOperandLiteral (IC_RIGHT (uic)))
2831 /* if shift operation make sure right side is not a literal */
2832 if (uic->op == RIGHT_OP &&
2833 (isOperandLiteral (IC_RIGHT (uic)) ||
2834 getSize (operandType (IC_RESULT (uic))) > 1))
2837 if (uic->op == LEFT_OP &&
2838 (isOperandLiteral (IC_RIGHT (uic)) ||
2839 getSize (operandType (IC_RESULT (uic))) > 1))
2842 /* make sure that the result of this icode is not on the
2843 stack, since acc is used to compute stack offset */
2844 if (isOperandOnStack(IC_RESULT(uic)))
2847 /* if either one of them in far space then we cannot */
2848 if ((IS_TRUE_SYMOP (IC_LEFT (uic)) &&
2849 isOperandInFarSpace (IC_LEFT (uic))) ||
2850 (IS_TRUE_SYMOP (IC_RIGHT (uic)) &&
2851 isOperandInFarSpace (IC_RIGHT (uic))))
2854 /* if the usage has only one operand then we can */
2855 if (IC_LEFT (uic) == NULL ||
2856 IC_RIGHT (uic) == NULL)
2859 /* make sure this is on the left side if not
2860 a '+' since '+' is commutative */
2861 if (ic->op != '+' &&
2862 IC_LEFT (uic)->key != IC_RESULT (ic)->key)
2865 /* if the other one is not on stack then we can */
2866 if (IC_LEFT (uic)->key == IC_RESULT (ic)->key &&
2867 (IS_ITEMP (IC_RIGHT (uic)) ||
2868 (IS_TRUE_SYMOP (IC_RIGHT (uic)) &&
2869 !OP_SYMBOL (IC_RIGHT (uic))->onStack)))
2872 if (IC_RIGHT (uic)->key == IC_RESULT (ic)->key &&
2873 (IS_ITEMP (IC_LEFT (uic)) ||
2874 (IS_TRUE_SYMOP (IC_LEFT (uic)) &&
2875 !OP_SYMBOL (IC_LEFT (uic))->onStack)))
2881 OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
2885 /*-----------------------------------------------------------------*/
2886 /* packForPush - heuristics to reduce iCode for pushing */
2887 /*-----------------------------------------------------------------*/
2889 packForPush (iCode * ic, eBBlock ** ebpp, int blockno)
2893 struct eBBlock * ebp = ebpp[blockno];
2895 if ((ic->op != IPUSH && ic->op != SEND) || !IS_ITEMP (IC_LEFT (ic)))
2898 /* must have only definition & one usage */
2899 if (bitVectnBitsOn (OP_DEFS (IC_LEFT (ic))) != 1 ||
2900 bitVectnBitsOn (OP_USES (IC_LEFT (ic))) != 1)
2903 /* find the definition */
2904 if (!(dic = hTabItemWithKey (iCodehTab,
2905 bitVectFirstBit (OP_DEFS (IC_LEFT (ic))))))
2908 if (dic->op != '=' || POINTER_SET (dic))
2911 if (dic->eBBlockNum != ic->eBBlockNum) return ;
2913 /* make sure the right side does not have any definitions
2915 dbv = OP_DEFS(IC_RIGHT(dic));
2916 for (lic = ic; lic && lic != dic ; lic = lic->prev) {
2917 if (bitVectBitValue (dbv, lic->key))
2920 /* make sure they have the same type */
2921 if (IS_SPEC(operandType(IC_LEFT(ic))))
2923 sym_link *itype=operandType(IC_LEFT(ic));
2924 sym_link *ditype=operandType(IC_RIGHT(dic));
2926 if (SPEC_USIGN(itype)!=SPEC_USIGN(ditype) ||
2927 SPEC_LONG(itype)!=SPEC_LONG(ditype))
2930 /* extend the live range of replaced operand if needed */
2931 if (OP_SYMBOL(IC_RIGHT(dic))->liveTo < OP_SYMBOL(IC_LEFT(ic))->liveTo) {
2932 OP_SYMBOL(IC_RIGHT(dic))->liveTo = OP_SYMBOL(IC_LEFT(ic))->liveTo;
2933 OP_SYMBOL(IC_RIGHT(dic))->clashes =
2934 bitVectUnion(OP_SYMBOL(IC_RIGHT(dic))->clashes,
2935 OP_SYMBOL(IC_LEFT(ic))->clashes);
2937 for (lic = ic; lic && lic != dic; lic = lic->prev)
2939 bitVectUnSetBit (lic->rlive, IC_LEFT (ic)->key);
2940 if (IS_ITEMP (IC_RIGHT (dic)))
2941 bitVectSetBit (lic->rlive, IC_RIGHT (dic)->key);
2943 /* we now we know that it has one & only one def & use
2944 and the that the definition is an assignment */
2945 IC_LEFT (ic) = IC_RIGHT (dic);
2947 remiCodeFromeBBlock (ebp, dic);
2948 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2949 hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2952 /*-----------------------------------------------------------------*/
2953 /* packRegisters - does some transformations to reduce register */
2955 /*-----------------------------------------------------------------*/
2957 packRegisters (eBBlock ** ebpp, int blockno)
2961 eBBlock *ebp = ebpp[blockno];
2967 /* look for assignments of the form */
2968 /* iTempNN = TRueSym (someoperation) SomeOperand */
2970 /* TrueSym := iTempNN:1 */
2971 for (ic = ebp->sch; ic; ic = ic->next)
2973 /* find assignment of the form TrueSym := iTempNN:1 */
2974 if (ic->op == '=' && !POINTER_SET (ic))
2975 change += packRegsForAssign (ic, ebp);
2982 for (ic = ebp->sch; ic; ic = ic->next)
2984 /* Fix for bug #979599: */
2987 /* Look for two subsequent iCodes with */
2989 /* _c = iTemp & op; */
2990 /* and replace them by */
2993 if ((ic->op == BITWISEAND || ic->op == '|' || ic->op == '^') &&
2995 ic->prev->op == '=' &&
2996 IS_ITEMP (IC_LEFT (ic)) &&
2997 IC_LEFT (ic) == IC_RESULT (ic->prev) &&
2998 isOperandEqual (IC_RESULT(ic), IC_RIGHT(ic->prev)))
3000 iCode* ic_prev = ic->prev;
3001 symbol* prev_result_sym = OP_SYMBOL (IC_RESULT (ic_prev));
3003 ReplaceOpWithCheaperOp (&IC_LEFT (ic), IC_RESULT (ic));
3004 if (IC_RESULT (ic_prev) != IC_RIGHT (ic))
3006 bitVectUnSetBit (OP_USES (IC_RESULT (ic_prev)), ic->key);
3007 if (/*IS_ITEMP (IC_RESULT (ic_prev)) && */
3008 prev_result_sym->liveTo == ic->seq)
3010 prev_result_sym->liveTo = ic_prev->seq;
3013 bitVectSetBit (OP_USES (IC_RESULT (ic)), ic->key);
3015 bitVectSetBit (ic->rlive, IC_RESULT (ic)->key);
3017 if (bitVectIsZero (OP_USES (IC_RESULT (ic_prev))))
3019 bitVectUnSetBit (ic->rlive, IC_RESULT (ic)->key);
3020 bitVectUnSetBit (OP_DEFS (IC_RESULT (ic_prev)), ic_prev->key);
3021 remiCodeFromeBBlock (ebp, ic_prev);
3022 hTabDeleteItem (&iCodehTab, ic_prev->key, ic_prev, DELETE_ITEM, NULL);
3026 /* if this is an itemp & result of an address of a true sym
3027 then mark this as rematerialisable */
3028 if (ic->op == ADDRESS_OF &&
3029 IS_ITEMP (IC_RESULT (ic)) &&
3030 IS_TRUE_SYMOP (IC_LEFT (ic)) &&
3031 bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
3032 !OP_SYMBOL (IC_LEFT (ic))->onStack)
3035 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
3036 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
3037 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
3041 /* if this is an itemp & used as a pointer
3042 & assigned to a literal then remat */
3043 if (IS_ASSIGN_ICODE(ic) &&
3044 IS_ITEMP(IC_RESULT(ic)) &&
3045 bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
3046 isOperandLiteral(IC_RIGHT(ic)))
3048 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
3049 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
3050 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
3053 /* if straight assignment then carry remat flag if
3054 this is the only definition */
3055 if (ic->op == '=' &&
3056 !POINTER_SET (ic) &&
3057 IS_SYMOP (IC_RIGHT (ic)) &&
3058 OP_SYMBOL (IC_RIGHT (ic))->remat &&
3059 !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode) &&
3060 bitVectnBitsOn (OP_SYMBOL (IC_RESULT (ic))->defs) <= 1)
3062 OP_SYMBOL (IC_RESULT (ic))->remat =
3063 OP_SYMBOL (IC_RIGHT (ic))->remat;
3064 OP_SYMBOL (IC_RESULT (ic))->rematiCode =
3065 OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
3068 /* if cast to a generic pointer & the pointer being
3069 cast is remat, then we can remat this cast as well */
3070 if (ic->op == CAST &&
3071 IS_SYMOP(IC_RIGHT(ic)) &&
3072 !OP_SYMBOL(IC_RESULT(ic))->isreqv &&
3073 OP_SYMBOL(IC_RIGHT(ic))->remat )
3075 sym_link *to_type = operandType(IC_LEFT(ic));
3076 sym_link *from_type = operandType(IC_RIGHT(ic));
3077 if (IS_GENPTR(to_type) && IS_PTR(from_type))
3079 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
3080 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
3081 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
3085 /* if this is a +/- operation with a rematerizable
3086 then mark this as rematerializable as well */
3087 if ((ic->op == '+' || ic->op == '-') &&
3088 (IS_SYMOP (IC_LEFT (ic)) &&
3089 IS_ITEMP (IC_RESULT (ic)) &&
3090 OP_SYMBOL (IC_LEFT (ic))->remat &&
3091 (!IS_SYMOP (IC_RIGHT (ic)) || !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode)) &&
3092 bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
3093 IS_OP_LITERAL (IC_RIGHT (ic))))
3096 //int i = operandLitValue(IC_RIGHT(ic));
3097 OP_SYMBOL (IC_RESULT (ic))->remat = 1;
3098 OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
3099 OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
3102 /* mark the pointer usages */
3103 if (POINTER_SET (ic) && IS_SYMOP (IC_RESULT (ic)))
3104 OP_SYMBOL (IC_RESULT (ic))->uptr = 1;
3106 if (POINTER_GET (ic) && IS_SYMOP (IC_LEFT (ic)))
3107 OP_SYMBOL (IC_LEFT (ic))->uptr = 1;
3109 if (ic->op == RETURN && IS_SYMOP (IC_LEFT(ic)))
3110 OP_SYMBOL (IC_LEFT (ic))->uptr = 1;
3112 if (ic->op == RECEIVE && ic->argreg == 1 &&
3113 IS_SYMOP (IC_RESULT (ic)) &&
3114 getSize (operandType(IC_RESULT(ic))) <= 3)
3115 OP_SYMBOL (IC_RESULT(ic))->uptr = 1;
3117 if (ic->op == SEND && ic->argreg == 1 &&
3118 IS_SYMOP(IC_LEFT(ic)) &&
3119 getSize (aggrToPtr(operandType(IC_LEFT(ic)),FALSE)) <= 3)
3120 OP_SYMBOL (IC_LEFT(ic))->uptr = 1;
3124 /* if we are using a symbol on the stack
3125 then we should say ds390_ptrRegReq */
3126 if (options.useXstack && ic->parmPush
3127 && (ic->op == IPUSH || ic->op == IPOP))
3129 if (ic->op == IFX && IS_SYMOP (IC_COND (ic)))
3130 ds390_ptrRegReq += ((OP_SYMBOL (IC_COND (ic))->onStack ? !options.stack10bit : 0) +
3131 OP_SYMBOL (IC_COND (ic))->iaccess +
3132 (SPEC_OCLS(OP_SYMBOL (IC_COND (ic))->etype) == idata));
3133 else if (ic->op == JUMPTABLE && IS_SYMOP (IC_JTCOND (ic)))
3134 ds390_ptrRegReq += ((OP_SYMBOL (IC_JTCOND (ic))->onStack ? !options.stack10bit : 0) +
3135 OP_SYMBOL (IC_JTCOND (ic))->iaccess +
3136 (SPEC_OCLS(OP_SYMBOL (IC_JTCOND (ic))->etype) == idata));
3139 if (IS_SYMOP (IC_LEFT (ic)))
3140 ds390_ptrRegReq += ((OP_SYMBOL (IC_LEFT (ic))->onStack ? !options.stack10bit : 0) +
3141 OP_SYMBOL (IC_LEFT (ic))->iaccess +
3142 (SPEC_OCLS(OP_SYMBOL (IC_LEFT (ic))->etype) == idata));
3143 if (IS_SYMOP (IC_RIGHT (ic)))
3144 ds390_ptrRegReq += ((OP_SYMBOL (IC_RIGHT (ic))->onStack ? !options.stack10bit : 0) +
3145 OP_SYMBOL (IC_RIGHT (ic))->iaccess +
3146 (SPEC_OCLS(OP_SYMBOL (IC_RIGHT (ic))->etype) == idata));
3147 if (IS_SYMOP (IC_RESULT (ic)))
3148 ds390_ptrRegReq += ((OP_SYMBOL (IC_RESULT (ic))->onStack ? !options.stack10bit : 0) +
3149 OP_SYMBOL (IC_RESULT (ic))->iaccess +
3150 (SPEC_OCLS(OP_SYMBOL (IC_RESULT (ic))->etype) == idata));
3154 /* if the condition of an if instruction
3155 is defined in the previous instruction and
3156 this is the only usage then
3157 mark the itemp as a conditional */
3158 if ((IS_CONDITIONAL (ic) ||
3159 (IS_BITWISE_OP(ic) && isBitwiseOptimizable (ic))) &&
3160 ic->next && ic->next->op == IFX &&
3161 bitVectnBitsOn (OP_USES(IC_RESULT(ic)))==1 &&
3162 isOperandEqual (IC_RESULT (ic), IC_COND (ic->next)) &&
3163 OP_SYMBOL (IC_RESULT (ic))->liveTo <= ic->next->seq)
3165 OP_SYMBOL (IC_RESULT (ic))->regType = REG_CND;
3169 /* reduce for support function calls */
3170 if (ic->supportRtn || ic->op == '+' || ic->op == '-')
3171 packRegsForSupport (ic, ebp);
3173 /* some cases the redundant moves can
3174 can be eliminated for return statements . Can be elminated for the first SEND */
3175 if ((ic->op == RETURN ||
3176 ((ic->op == SEND || ic->op == RECEIVE)&& ic->argreg == 1)) &&
3177 !isOperandInFarSpace (IC_LEFT (ic)) &&
3180 packRegsDPTRuse (IC_LEFT (ic));
3183 if (ic->op == CALL) {
3184 sym_link *ftype = operandType(IC_LEFT(ic));
3185 if (getSize(operandType(IC_RESULT(ic))) <= 4 &&
3186 !IFFUNC_ISBUILTIN(ftype)) {
3187 packRegsDPTRuse (IC_RESULT (ic));
3191 /* if pointer set & left has a size more than
3192 one and right is not in far space */
3193 if (POINTER_SET (ic) &&
3194 !isOperandInFarSpace (IC_RIGHT (ic)) &&
3195 IS_SYMOP (IC_RESULT (ic)) &&
3196 !OP_SYMBOL (IC_RESULT (ic))->remat &&
3197 !IS_OP_RUONLY (IC_RIGHT (ic)) &&
3198 getSize (aggrToPtr (operandType (IC_RESULT (ic)), FALSE)) > 1) {
3200 packRegsDPTRuse (IC_RESULT (ic));
3203 /* if pointer get */
3204 if (POINTER_GET (ic) &&
3205 !isOperandInFarSpace (IC_RESULT (ic)) &&
3206 IS_SYMOP (IC_LEFT (ic)) &&
3207 !OP_SYMBOL (IC_LEFT (ic))->remat &&
3208 !IS_OP_RUONLY (IC_RESULT (ic)) &&
3209 getSize (aggrToPtr (operandType (IC_LEFT (ic)), FALSE)) > 1) {
3211 packRegsDPTRuse (IC_LEFT (ic));
3214 /* if this is a cast for intergral promotion then
3215 check if it's the only use of the definition of the
3216 operand being casted/ if yes then replace
3217 the result of that arithmetic operation with
3218 this result and get rid of the cast */
3221 sym_link *fromType = operandType (IC_RIGHT (ic));
3222 sym_link *toType = operandType (IC_LEFT (ic));
3224 if (IS_INTEGRAL (fromType) && IS_INTEGRAL (toType) &&
3225 getSize (fromType) != getSize (toType) &&
3226 SPEC_USIGN (fromType) == SPEC_USIGN (toType))
3229 iCode *dic = packRegsDPTRuse (IC_RIGHT (ic));
3232 if (IS_ARITHMETIC_OP (dic))
3234 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
3235 IC_RESULT (dic) = IC_RESULT (ic);
3236 remiCodeFromeBBlock (ebp, ic);
3237 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
3238 hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
3239 OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
3243 OP_SYMBOL (IC_RIGHT (ic))->ruonly = 0;
3249 /* if the type from and type to are the same
3250 then if this is the only use then packit */
3251 if (compareType (operandType (IC_RIGHT (ic)),
3252 operandType (IC_LEFT (ic))) == 1)
3254 iCode *dic = packRegsDPTRuse (IC_RIGHT (ic));
3257 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
3258 IC_RESULT (dic) = IC_RESULT (ic);
3259 remiCodeFromeBBlock (ebp, ic);
3260 bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
3261 hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
3262 OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
3270 iTempNN := (some variable in farspace) V1
3275 if (ic->op == IPUSH || ic->op == SEND)
3277 packForPush (ic, ebpp, blockno);
3281 /* pack registers for accumulator use, when the
3282 result of an arithmetic or bit wise operation
3283 has only one use, that use is immediately following
3284 the defintion and the using iCode has only one
3285 operand or has two operands but one is literal &
3286 the result of that operation is not on stack then
3287 we can leave the result of this operation in acc:b
3289 if ((IS_ARITHMETIC_OP (ic)
3290 || IS_CONDITIONAL(ic)
3291 || IS_BITWISE_OP (ic)
3292 || ic->op == LEFT_OP || ic->op == RIGHT_OP
3293 || (ic->op == ADDRESS_OF && isOperandOnStack (IC_LEFT (ic)))
3295 IS_ITEMP (IC_RESULT (ic)) &&
3296 getSize (operandType (IC_RESULT (ic))) <= 2)
3298 packRegsForAccUse (ic);
3302 /*-----------------------------------------------------------------*/
3303 /* assignRegisters - assigns registers to each live range as need */
3304 /*-----------------------------------------------------------------*/
3306 ds390_assignRegisters (ebbIndex * ebbi)
3308 eBBlock ** ebbs = ebbi->bbOrder;
3309 int count = ebbi->count;
3313 setToNull ((void *) &_G.funcrUsed);
3314 setToNull ((void *) &_G.regAssigned);
3315 setToNull ((void *) &_G.totRegAssigned);
3316 setToNull ((void *) &_G.funcrUsed);
3317 ds390_ptrRegReq = _G.stackExtend = _G.dataExtend = 0;
3318 if ((currFunc && IFFUNC_ISREENT (currFunc->type)) || options.stackAuto)
3326 ds390_nRegs = 12 + ds390_nBitRegs;
3327 _G.allBitregs = findAllBitregs ();
3329 if (options.model != MODEL_FLAT24)
3330 options.stack10bit = 0;
3331 /* change assignments this will remove some
3332 live ranges reducing some register pressure */
3333 for (i = 0; i < count; i++)
3334 packRegisters (ebbs, i);
3336 /* liveranges probably changed by register packing
3337 so we compute them again */
3338 recomputeLiveRanges (ebbs, count);
3340 if (options.dump_pack)
3341 dumpEbbsToFileExt (DUMP_PACK, ebbi);
3343 /* first determine for each live range the number of
3344 registers & the type of registers required for each */
3347 /* and serially allocate registers */
3348 serialRegAssign (ebbs, count);
3353 ds390_nRegs = 12 + ds390_nBitRegs;
3355 /* if stack was extended then tell the user */
3358 /* werror(W_TOOMANY_SPILS,"stack", */
3359 /* _G.stackExtend,currFunc->name,""); */
3365 /* werror(W_TOOMANY_SPILS,"data space", */
3366 /* _G.dataExtend,currFunc->name,""); */
3370 /* after that create the register mask
3371 for each of the instruction */
3372 createRegMask (ebbs, count);
3374 /* redo that offsets for stacked automatic variables */
3376 redoStackOffsets ();
3378 /* make sure r0 & r1 are flagged as used if they might be used */
3380 if (currFunc && ds390_ptrRegReq)
3382 currFunc->regsUsed = bitVectSetBit (currFunc->regsUsed, R0_IDX);
3383 currFunc->regsUsed = bitVectSetBit (currFunc->regsUsed, R1_IDX);
3386 if (options.dump_rassgn)
3388 dumpEbbsToFileExt (DUMP_RASSGN, ebbi);
3389 dumpLiveRanges (DUMP_LRANGE, liveRanges);
3392 /* do the overlaysegment stuff SDCCmem.c */
3393 doOverlays (ebbs, count);
3395 /* now get back the chain */
3396 ic = iCodeLabelOptimize (iCodeFromeBBlock (ebbs, count));
3400 /* free up any _G.stackSpil locations allocated */
3401 applyToSet (_G.stackSpil, deallocStackSpil);
3403 setToNull ((void *) &_G.stackSpil);
3404 setToNull ((void *) &_G.spiltSet);
3405 /* mark all registers as free */