git.gag.com Git - fw/sdcc/blob - src/mcs51/ralloc.c

   1 /*------------------------------------------------------------------------
   2
   3   SDCCralloc.c - source file for register allocation. (8051) specific
   4
   5                 Written By -  Sandeep Dutta . sandeep.dutta@usa.net (1998)
   6
   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
  10    later version.
  11
  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.
  16
  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.
  20
  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 -------------------------------------------------------------------------*/
  25
  26 #include "common.h"
  27 #include "ralloc.h"
  28 #include "gen.h"
  29
  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 /*-----------------------------------------------------------------*/
  38
  39 extern void gen51Code (iCode *);
  40 #define D(x)
  41
  42 /* Global data */
  43 static struct
  44   {
  45     bitVect *spiltSet;
  46     set *stackSpil;
  47     bitVect *regAssigned;
  48     bitVect *totRegAssigned;    /* final set of LRs that got into registers */
  49     short blockSpil;
  50     int slocNum;
  51     bitVect *funcrUsed;         /* registers used in a function */
  52     int stackExtend;
  53     int dataExtend;
  54   }
  55 _G;
  56
  57 /* Shared with gen.c */
  58 int mcs51_ptrRegReq;            /* one byte pointer register required */
  59
  60 /* 8051 registers */
  61 regs regs8051[] =
  62 {
  63
  64   {REG_GPR, R2_IDX,  REG_GPR, "r2",  "ar2", "0",    2, 1},
  65   {REG_GPR, R3_IDX,  REG_GPR, "r3",  "ar3", "0",    3, 1},
  66   {REG_GPR, R4_IDX,  REG_GPR, "r4",  "ar4", "0",    4, 1},
  67   {REG_GPR, R5_IDX,  REG_GPR, "r5",  "ar5", "0",    5, 1},
  68   {REG_GPR, R6_IDX,  REG_GPR, "r6",  "ar6", "0",    6, 1},
  69   {REG_GPR, R7_IDX,  REG_GPR, "r7",  "ar7", "0",    7, 1},
  70   {REG_PTR, R0_IDX,  REG_PTR, "r0",  "ar0", "0",    0, 1},
  71   {REG_PTR, R1_IDX,  REG_PTR, "r1",  "ar1", "0",    1, 1},
  72   {REG_GPR, X8_IDX,  REG_GPR, "x8",  "x8",  "xreg", 0, 1},
  73   {REG_GPR, X9_IDX,  REG_GPR, "x9",  "x9",  "xreg", 1, 1},
  74   {REG_GPR, X10_IDX, REG_GPR, "x10", "x10", "xreg", 2, 1},
  75   {REG_GPR, X11_IDX, REG_GPR, "x11", "x11", "xreg", 3, 1},
  76   {REG_GPR, X12_IDX, REG_GPR, "x12", "x12", "xreg", 4, 1},
  77   {REG_CND, CND_IDX, REG_CND, "C",   "psw", "0xd0", 0, 1},
  78   {0,       DPL_IDX, 0,       "dpl", "dpl", "0x82", 0, 0},
  79   {0,       DPH_IDX, 0,       "dph", "dph", "0x83", 0, 0},
  80   {0,       B_IDX,   0,       "b",   "b",   "0xf0", 0, 0},
  81   {0,       A_IDX,   0,       "a",   "acc", "0xe0", 0, 0},
  82 };
  83 int mcs51_nRegs = 17;
  84 static void spillThis (symbol *);
  85 static void freeAllRegs ();
  86
  87 /*-----------------------------------------------------------------*/
  88 /* allocReg - allocates register of given type                     */
  89 /*-----------------------------------------------------------------*/
  90 static regs *
  91 allocReg (short type)
  92 {
  93   int i;
  94
  95   for (i = 0; i < mcs51_nRegs; i++)
  96     {
  97
  98       /* if type is given as 0 then any
  99          free register will do */
 100       if (!type &&
 101           regs8051[i].isFree)
 102         {
 103           regs8051[i].isFree = 0;
 104           if (currFunc)
 105             currFunc->regsUsed =
 106               bitVectSetBit (currFunc->regsUsed, i);
 107           return &regs8051[i];
 108         }
 109       /* other wise look for specific type
 110          of register */
 111       if (regs8051[i].isFree &&
 112           regs8051[i].type == type)
 113         {
 114           regs8051[i].isFree = 0;
 115           if (currFunc)
 116             currFunc->regsUsed =
 117               bitVectSetBit (currFunc->regsUsed, i);
 118           return &regs8051[i];
 119         }
 120     }
 121   return NULL;
 122 }
 123
 124 /*-----------------------------------------------------------------*/
 125 /* allocThisReg - allocates a particular register (if free)        */
 126 /*-----------------------------------------------------------------*/
 127 static regs *
 128 allocThisReg (regs * reg)
 129 {
 130   if (!reg->isFree)
 131     return NULL;
 132
 133   reg->isFree = 0;
 134   if (currFunc)
 135     currFunc->regsUsed = bitVectSetBit (currFunc->regsUsed, reg->rIdx);
 136
 137   return reg;
 138 }
 139
 140
 141 /*-----------------------------------------------------------------*/
 142 /* mcs51_regWithIdx - returns pointer to register with index number*/
 143 /*-----------------------------------------------------------------*/
 144 regs *
 145 mcs51_regWithIdx (int idx)
 146 {
 147   int i;
 148
 149   for (i = 0; i < sizeof(regs8051)/sizeof(regs); i++)
 150     if (regs8051[i].rIdx == idx)
 151       return &regs8051[i];
 152
 153   werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
 154           "regWithIdx not found");
 155   exit (1);
 156 }
 157
 158 /*-----------------------------------------------------------------*/
 159 /* freeReg - frees a register                                      */
 160 /*-----------------------------------------------------------------*/
 161 static void
 162 freeReg (regs * reg)
 163 {
 164   if (!reg)
 165     {
 166       werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
 167               "freeReg - Freeing NULL register");
 168       exit (1);
 169     }
 170
 171   reg->isFree = 1;
 172 }
 173
 174
 175 /*-----------------------------------------------------------------*/
 176 /* nFreeRegs - returns number of free registers                    */
 177 /*-----------------------------------------------------------------*/
 178 static int
 179 nFreeRegs (int type)
 180 {
 181   int i;
 182   int nfr = 0;
 183
 184   for (i = 0; i < mcs51_nRegs; i++)
 185     if (regs8051[i].isFree && regs8051[i].type == type)
 186       nfr++;
 187   return nfr;
 188 }
 189
 190 /*-----------------------------------------------------------------*/
 191 /* nfreeRegsType - free registers with type                         */
 192 /*-----------------------------------------------------------------*/
 193 static int
 194 nfreeRegsType (int type)
 195 {
 196   int nfr;
 197   if (type == REG_PTR)
 198     {
 199       if ((nfr = nFreeRegs (type)) == 0)
 200         return nFreeRegs (REG_GPR);
 201     }
 202
 203   return nFreeRegs (type);
 204 }
 205
 206 /*-----------------------------------------------------------------*/
 207 /* useReg - marks a register  as used                              */
 208 /*-----------------------------------------------------------------*/
 209 static void
 210 useReg (regs * reg)
 211 {
 212   reg->isFree = 0;
 213 }
 214
 215 /*-----------------------------------------------------------------*/
 216 /* computeSpillable - given a point find the spillable live ranges */
 217 /*-----------------------------------------------------------------*/
 218 static bitVect *
 219 computeSpillable (iCode * ic)
 220 {
 221   bitVect *spillable;
 222
 223   /* spillable live ranges are those that are live at this
 224      point . the following categories need to be subtracted
 225      from this set.
 226      a) - those that are already spilt
 227      b) - if being used by this one
 228      c) - defined by this one */
 229
 230   spillable = bitVectCopy (ic->rlive);
 231   spillable =
 232     bitVectCplAnd (spillable, _G.spiltSet);     /* those already spilt */
 233   spillable =
 234     bitVectCplAnd (spillable, ic->uses);        /* used in this one */
 235   bitVectUnSetBit (spillable, ic->defKey);
 236   spillable = bitVectIntersect (spillable, _G.regAssigned);
 237   return spillable;
 238
 239 }
 240
 241 /*-----------------------------------------------------------------*/
 242 /* noSpilLoc - return true if a variable has no spil location      */
 243 /*-----------------------------------------------------------------*/
 244 static int
 245 noSpilLoc (symbol * sym, eBBlock * ebp, iCode * ic)
 246 {
 247   return (sym->usl.spillLoc ? 0 : 1);
 248 }
 249
 250 /*-----------------------------------------------------------------*/
 251 /* hasSpilLoc - will return 1 if the symbol has spil location      */
 252 /*-----------------------------------------------------------------*/
 253 static int
 254 hasSpilLoc (symbol * sym, eBBlock * ebp, iCode * ic)
 255 {
 256   return (sym->usl.spillLoc ? 1 : 0);
 257 }
 258
 259 /*-----------------------------------------------------------------*/
 260 /* directSpilLoc - will return 1 if the splilocation is in direct  */
 261 /*-----------------------------------------------------------------*/
 262 static int
 263 directSpilLoc (symbol * sym, eBBlock * ebp, iCode * ic)
 264 {
 265   if (sym->usl.spillLoc &&
 266       (IN_DIRSPACE (SPEC_OCLS (sym->usl.spillLoc->etype))))
 267     return 1;
 268   else
 269     return 0;
 270 }
 271
 272 /*-----------------------------------------------------------------*/
 273 /* hasSpilLocnoUptr - will return 1 if the symbol has spil location */
 274 /*                    but is not used as a pointer                 */
 275 /*-----------------------------------------------------------------*/
 276 static int
 277 hasSpilLocnoUptr (symbol * sym, eBBlock * ebp, iCode * ic)
 278 {
 279   return ((sym->usl.spillLoc && !sym->uptr) ? 1 : 0);
 280 }
 281
 282 /*-----------------------------------------------------------------*/
 283 /* rematable - will return 1 if the remat flag is set              */
 284 /*-----------------------------------------------------------------*/
 285 static int
 286 rematable (symbol * sym, eBBlock * ebp, iCode * ic)
 287 {
 288   return sym->remat;
 289 }
 290
 291 /*-----------------------------------------------------------------*/
 292 /* notUsedInRemaining - not used or defined in remain of the block */
 293 /*-----------------------------------------------------------------*/
 294 static int
 295 notUsedInRemaining (symbol * sym, eBBlock * ebp, iCode * ic)
 296 {
 297   return ((usedInRemaining (operandFromSymbol (sym), ic) ? 0 : 1) &&
 298           allDefsOutOfRange (sym->defs, ebp->fSeq, ebp->lSeq));
 299 }
 300
 301 /*-----------------------------------------------------------------*/
 302 /* allLRs - return true for all                                    */
 303 /*-----------------------------------------------------------------*/
 304 static int
 305 allLRs (symbol * sym, eBBlock * ebp, iCode * ic)
 306 {
 307   return 1;
 308 }
 309
 310 /*-----------------------------------------------------------------*/
 311 /* liveRangesWith - applies function to a given set of live range  */
 312 /*-----------------------------------------------------------------*/
 313 static set *
 314 liveRangesWith (bitVect * lrs, int (func) (symbol *, eBBlock *, iCode *),
 315                 eBBlock * ebp, iCode * ic)
 316 {
 317   set *rset = NULL;
 318   int i;
 319
 320   if (!lrs || !lrs->size)
 321     return NULL;
 322
 323   for (i = 1; i < lrs->size; i++)
 324     {
 325       symbol *sym;
 326       if (!bitVectBitValue (lrs, i))
 327         continue;
 328
 329       /* if we don't find it in the live range
 330          hash table we are in serious trouble */
 331       if (!(sym = hTabItemWithKey (liveRanges, i)))
 332         {
 333           werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
 334                   "liveRangesWith could not find liveRange");
 335           exit (1);
 336         }
 337
 338       if (func (sym, ebp, ic) && bitVectBitValue (_G.regAssigned, sym->key))
 339         addSetHead (&rset, sym);
 340     }
 341
 342   return rset;
 343 }
 344
 345
 346 /*-----------------------------------------------------------------*/
 347 /* leastUsedLR - given a set determines which is the least used    */
 348 /*-----------------------------------------------------------------*/
 349 static symbol *
 350 leastUsedLR (set * sset)
 351 {
 352   symbol *sym = NULL, *lsym = NULL;
 353
 354   sym = lsym = setFirstItem (sset);
 355
 356   if (!lsym)
 357     return NULL;
 358
 359   for (; lsym; lsym = setNextItem (sset))
 360     {
 361
 362       /* if usage is the same then prefer
 363          the spill the smaller of the two */
 364       if (lsym->used == sym->used)
 365         if (getSize (lsym->type) < getSize (sym->type))
 366           sym = lsym;
 367
 368       /* if less usage */
 369       if (lsym->used < sym->used)
 370         sym = lsym;
 371
 372     }
 373
 374   setToNull ((void *) &sset);
 375   sym->blockSpil = 0;
 376   return sym;
 377 }
 378
 379 /*-----------------------------------------------------------------*/
 380 /* noOverLap - will iterate through the list looking for over lap  */
 381 /*-----------------------------------------------------------------*/
 382 static int
 383 noOverLap (set * itmpStack, symbol * fsym)
 384 {
 385   symbol *sym;
 386
 387   for (sym = setFirstItem (itmpStack); sym;
 388        sym = setNextItem (itmpStack))
 389     {
 390         if (bitVectBitValue(sym->clashes,fsym->key)) return 0;
 391     }
 392   return 1;
 393 }
 394
 395 /*-----------------------------------------------------------------*/
 396 /* isFree - will return 1 if the a free spil location is found     */
 397 /*-----------------------------------------------------------------*/
 398 static
 399 DEFSETFUNC (isFree)
 400 {
 401   symbol *sym = item;
 402   V_ARG (symbol **, sloc);
 403   V_ARG (symbol *, fsym);
 404
 405   /* if already found */
 406   if (*sloc)
 407     return 0;
 408
 409   /* if it is free && and the itmp assigned to
 410      this does not have any overlapping live ranges
 411      with the one currently being assigned and
 412      the size can be accomodated  */
 413   if (sym->isFree &&
 414       noOverLap (sym->usl.itmpStack, fsym) &&
 415       getSize (sym->type) >= getSize (fsym->type))
 416     {
 417       *sloc = sym;
 418       return 1;
 419     }
 420
 421   return 0;
 422 }
 423
 424 /*-----------------------------------------------------------------*/
 425 /* spillLRWithPtrReg :- will spil those live ranges which use PTR  */
 426 /*-----------------------------------------------------------------*/
 427 static void
 428 spillLRWithPtrReg (symbol * forSym)
 429 {
 430   symbol *lrsym;
 431   regs *r0, *r1;
 432   int k;
 433
 434   if (!_G.regAssigned ||
 435       bitVectIsZero (_G.regAssigned))
 436     return;
 437
 438   r0 = mcs51_regWithIdx (R0_IDX);
 439   r1 = mcs51_regWithIdx (R1_IDX);
 440
 441   /* for all live ranges */
 442   for (lrsym = hTabFirstItem (liveRanges, &k); lrsym;
 443        lrsym = hTabNextItem (liveRanges, &k))
 444     {
 445       int j;
 446
 447       /* if no registers assigned to it or spilt */
 448       /* if it does not overlap this then
 449          no need to spill it */
 450
 451       if (lrsym->isspilt || !lrsym->nRegs ||
 452           (lrsym->liveTo < forSym->liveFrom))
 453         continue;
 454
 455       /* go thru the registers : if it is either
 456          r0 or r1 then spill it */
 457       for (j = 0; j < lrsym->nRegs; j++)
 458         if (lrsym->regs[j] == r0 ||
 459             lrsym->regs[j] == r1)
 460           {
 461             spillThis (lrsym);
 462             break;
 463           }
 464     }
 465
 466 }
 467
 468 /*-----------------------------------------------------------------*/
 469 /* createStackSpil - create a location on the stack to spil        */
 470 /*-----------------------------------------------------------------*/
 471 static symbol *
 472 createStackSpil (symbol * sym)
 473 {
 474   symbol *sloc = NULL;
 475   int useXstack, model;
 476
 477   char slocBuffer[30];
 478
 479   /* first go try and find a free one that is already
 480      existing on the stack */
 481   if (applyToSet (_G.stackSpil, isFree, &sloc, sym))
 482     {
 483       /* found a free one : just update & return */
 484       sym->usl.spillLoc = sloc;
 485       sym->stackSpil = 1;
 486       sloc->isFree = 0;
 487       addSetHead (&sloc->usl.itmpStack, sym);
 488       return sym;
 489     }
 490
 491   /* could not then have to create one , this is the hard part
 492      we need to allocate this on the stack : this is really a
 493      hack!! but cannot think of anything better at this time */
 494
 495   if (SNPRINTF (slocBuffer, sizeof(slocBuffer),
 496                 "sloc%d", _G.slocNum++) >= sizeof (slocBuffer))
 497     {
 498       fprintf (stderr, "***Internal error: slocBuffer overflowed: %s:%d\n",
 499                __FILE__, __LINE__);
 500       exit (1);
 501     }
 502
 503   sloc = newiTemp (slocBuffer);
 504
 505   /* set the type to the spilling symbol */
 506   sloc->type = copyLinkChain (sym->type);
 507   sloc->etype = getSpec (sloc->type);
 508   if (SPEC_SCLS (sloc->etype) != S_BIT)
 509     {
 510       SPEC_SCLS (sloc->etype) = S_DATA;
 511     }
 512   SPEC_EXTR (sloc->etype) = 0;
 513   SPEC_STAT (sloc->etype) = 0;
 514   SPEC_VOLATILE(sloc->etype) = 0;
 515   SPEC_ABSA(sloc->etype) = 0;
 516
 517   /* we don't allow it to be allocated`
 518      onto the external stack since : so we
 519      temporarily turn it off ; we also
 520      turn off memory model to prevent
 521      the spil from going to the external storage
 522    */
 523
 524   useXstack = options.useXstack;
 525   model = options.model;
 526 /*     noOverlay = options.noOverlay; */
 527 /*     options.noOverlay = 1; */
 528   options.model = options.useXstack = 0;
 529
 530   allocLocal (sloc);
 531
 532   options.useXstack = useXstack;
 533   options.model = model;
 534 /*     options.noOverlay = noOverlay; */
 535   sloc->isref = 1;              /* to prevent compiler warning */
 536
 537   /* if it is on the stack then update the stack */
 538   if (IN_STACK (sloc->etype))
 539     {
 540       currFunc->stack += getSize (sloc->type);
 541       _G.stackExtend += getSize (sloc->type);
 542     }
 543   else
 544     _G.dataExtend += getSize (sloc->type);
 545
 546   /* add it to the _G.stackSpil set */
 547   addSetHead (&_G.stackSpil, sloc);
 548   sym->usl.spillLoc = sloc;
 549   sym->stackSpil = 1;
 550
 551   /* add it to the set of itempStack set
 552      of the spill location */
 553   addSetHead (&sloc->usl.itmpStack, sym);
 554   return sym;
 555 }
 556
 557 /*-----------------------------------------------------------------*/
 558 /* isSpiltOnStack - returns true if the spil location is on stack  */
 559 /*-----------------------------------------------------------------*/
 560 static bool
 561 isSpiltOnStack (symbol * sym)
 562 {
 563   sym_link *etype;
 564
 565   if (!sym)
 566     return FALSE;
 567
 568   if (!sym->isspilt)
 569     return FALSE;
 570
 571 /*     if (sym->_G.stackSpil) */
 572 /*      return TRUE; */
 573
 574   if (!sym->usl.spillLoc)
 575     return FALSE;
 576
 577   etype = getSpec (sym->usl.spillLoc->type);
 578   if (IN_STACK (etype))
 579     return TRUE;
 580
 581   return FALSE;
 582 }
 583
 584 /*-----------------------------------------------------------------*/
 585 /* spillThis - spils a specific operand                            */
 586 /*-----------------------------------------------------------------*/
 587 static void
 588 spillThis (symbol * sym)
 589 {
 590   int i;
 591   /* if this is rematerializable or has a spillLocation
 592      we are okay, else we need to create a spillLocation
 593      for it */
 594   if (!(sym->remat || sym->usl.spillLoc))
 595     createStackSpil (sym);
 596
 597   /* mark it has spilt & put it in the spilt set */
 598   sym->isspilt = sym->spillA = 1;
 599   _G.spiltSet = bitVectSetBit (_G.spiltSet, sym->key);
 600
 601   bitVectUnSetBit (_G.regAssigned, sym->key);
 602   bitVectUnSetBit (_G.totRegAssigned, sym->key);
 603
 604   for (i = 0; i < sym->nRegs; i++)
 605
 606     if (sym->regs[i])
 607       {
 608         freeReg (sym->regs[i]);
 609         sym->regs[i] = NULL;
 610       }
 611
 612   /* if spilt on stack then free up r0 & r1
 613      if they could have been assigned to some
 614      LIVE ranges */
 615   if (!mcs51_ptrRegReq && isSpiltOnStack (sym))
 616     {
 617       mcs51_ptrRegReq++;
 618       spillLRWithPtrReg (sym);
 619     }
 620
 621   if (sym->usl.spillLoc && !sym->remat)
 622     sym->usl.spillLoc->allocreq++;
 623   return;
 624 }
 625
 626 /*-----------------------------------------------------------------*/
 627 /* selectSpil - select a iTemp to spil : rather a simple procedure */
 628 /*-----------------------------------------------------------------*/
 629 static symbol *
 630 selectSpil (iCode * ic, eBBlock * ebp, symbol * forSym)
 631 {
 632   bitVect *lrcs = NULL;
 633   set *selectS;
 634   symbol *sym;
 635
 636   /* get the spillable live ranges */
 637   lrcs = computeSpillable (ic);
 638
 639   /* get all live ranges that are rematerizable */
 640   if ((selectS = liveRangesWith (lrcs, rematable, ebp, ic)))
 641     {
 642
 643       /* return the least used of these */
 644       return leastUsedLR (selectS);
 645     }
 646
 647   /* get live ranges with spillLocations in direct space */
 648   if ((selectS = liveRangesWith (lrcs, directSpilLoc, ebp, ic)))
 649     {
 650       sym = leastUsedLR (selectS);
 651       strncpyz (sym->rname,
 652                 sym->usl.spillLoc->rname[0] ?
 653                    sym->usl.spillLoc->rname : sym->usl.spillLoc->name,
 654                 sizeof(sym->rname));
 655       sym->spildir = 1;
 656       /* mark it as allocation required */
 657       sym->usl.spillLoc->allocreq++;
 658       return sym;
 659     }
 660
 661   /* if the symbol is local to the block then */
 662   if (forSym->liveTo < ebp->lSeq)
 663     {
 664
 665       /* check if there are any live ranges allocated
 666          to registers that are not used in this block */
 667       if (!_G.blockSpil && (selectS = liveRangesWith (lrcs, notUsedInBlock, ebp, ic)))
 668         {
 669           sym = leastUsedLR (selectS);
 670           /* if this is not rematerializable */
 671           if (!sym->remat)
 672             {
 673               _G.blockSpil++;
 674               sym->blockSpil = 1;
 675             }
 676           return sym;
 677         }
 678
 679       /* check if there are any live ranges that not
 680          used in the remainder of the block */
 681       if (!_G.blockSpil &&
 682           !isiCodeInFunctionCall (ic) &&
 683           (selectS = liveRangesWith (lrcs, notUsedInRemaining, ebp, ic)))
 684         {
 685           sym = leastUsedLR (selectS);
 686           if (sym != forSym)
 687             {
 688               if (!sym->remat)
 689                 {
 690                   sym->remainSpil = 1;
 691                   _G.blockSpil++;
 692                 }
 693               return sym;
 694             }
 695         }
 696     }
 697
 698   /* find live ranges with spillocation && not used as pointers */
 699   if ((selectS = liveRangesWith (lrcs, hasSpilLocnoUptr, ebp, ic)))
 700     {
 701
 702       sym = leastUsedLR (selectS);
 703       /* mark this as allocation required */
 704       sym->usl.spillLoc->allocreq++;
 705       return sym;
 706     }
 707
 708   /* find live ranges with spillocation */
 709   if ((selectS = liveRangesWith (lrcs, hasSpilLoc, ebp, ic)))
 710     {
 711
 712       sym = leastUsedLR (selectS);
 713       sym->usl.spillLoc->allocreq++;
 714       return sym;
 715     }
 716
 717   /* couldn't find then we need to create a spil
 718      location on the stack , for which one? the least
 719      used ofcourse */
 720   if ((selectS = liveRangesWith (lrcs, noSpilLoc, ebp, ic)))
 721     {
 722
 723       /* return a created spil location */
 724       sym = createStackSpil (leastUsedLR (selectS));
 725       sym->usl.spillLoc->allocreq++;
 726       return sym;
 727     }
 728
 729   /* this is an extreme situation we will spill
 730      this one : happens very rarely but it does happen */
 731   spillThis (forSym);
 732   return forSym;
 733
 734 }
 735
 736 /*-----------------------------------------------------------------*/
 737 /* spilSomething - spil some variable & mark registers as free     */
 738 /*-----------------------------------------------------------------*/
 739 static bool
 740 spilSomething (iCode * ic, eBBlock * ebp, symbol * forSym)
 741 {
 742   symbol *ssym;
 743   int i;
 744
 745   /* get something we can spil */
 746   ssym = selectSpil (ic, ebp, forSym);
 747
 748   /* mark it as spilt */
 749   ssym->isspilt = ssym->spillA = 1;
 750   _G.spiltSet = bitVectSetBit (_G.spiltSet, ssym->key);
 751
 752   /* mark it as not register assigned &
 753      take it away from the set */
 754   bitVectUnSetBit (_G.regAssigned, ssym->key);
 755   bitVectUnSetBit (_G.totRegAssigned, ssym->key);
 756
 757   /* mark the registers as free */
 758   for (i = 0; i < ssym->nRegs; i++)
 759     if (ssym->regs[i])
 760       freeReg (ssym->regs[i]);
 761
 762   /* if spilt on stack then free up r0 & r1
 763      if they could have been assigned to as gprs */
 764   if (!mcs51_ptrRegReq && isSpiltOnStack (ssym))
 765     {
 766       mcs51_ptrRegReq++;
 767       spillLRWithPtrReg (ssym);
 768     }
 769
 770   /* if this was a block level spil then insert push & pop
 771      at the start & end of block respectively */
 772   if (ssym->blockSpil)
 773     {
 774       iCode *nic = newiCode (IPUSH, operandFromSymbol (ssym), NULL);
 775       /* add push to the start of the block */
 776       addiCodeToeBBlock (ebp, nic, (ebp->sch->op == LABEL ?
 777                                     ebp->sch->next : ebp->sch));
 778       nic = newiCode (IPOP, operandFromSymbol (ssym), NULL);
 779       /* add pop to the end of the block */
 780       addiCodeToeBBlock (ebp, nic, NULL);
 781     }
 782
 783   /* if spilt because not used in the remainder of the
 784      block then add a push before this instruction and
 785      a pop at the end of the block */
 786   if (ssym->remainSpil)
 787     {
 788
 789       iCode *nic = newiCode (IPUSH, operandFromSymbol (ssym), NULL);
 790       /* add push just before this instruction */
 791       addiCodeToeBBlock (ebp, nic, ic);
 792
 793       nic = newiCode (IPOP, operandFromSymbol (ssym), NULL);
 794       /* add pop to the end of the block */
 795       addiCodeToeBBlock (ebp, nic, NULL);
 796     }
 797
 798   if (ssym == forSym)
 799     return FALSE;
 800   else
 801     return TRUE;
 802 }
 803
 804 /*-----------------------------------------------------------------*/
 805 /* getRegPtr - will try for PTR if not a GPR type if not spil      */
 806 /*-----------------------------------------------------------------*/
 807 static regs *
 808 getRegPtr (iCode * ic, eBBlock * ebp, symbol * sym)
 809 {
 810   regs *reg;
 811   int j;
 812
 813 tryAgain:
 814   /* try for a ptr type */
 815   if ((reg = allocReg (REG_PTR)))
 816     return reg;
 817
 818   /* try for gpr type */
 819   if ((reg = allocReg (REG_GPR)))
 820     return reg;
 821
 822   /* we have to spil */
 823   if (!spilSomething (ic, ebp, sym))
 824     return NULL;
 825
 826   /* make sure partially assigned registers aren't reused */
 827   for (j=0; j<=sym->nRegs; j++)
 828     if (sym->regs[j])
 829       sym->regs[j]->isFree = 0;
 830
 831   /* this looks like an infinite loop but
 832      in really selectSpil will abort  */
 833   goto tryAgain;
 834 }
 835
 836 /*-----------------------------------------------------------------*/
 837 /* getRegGpr - will try for GPR if not spil                        */
 838 /*-----------------------------------------------------------------*/
 839 static regs *
 840 getRegGpr (iCode * ic, eBBlock * ebp, symbol * sym)
 841 {
 842   regs *reg;
 843   int j;
 844
 845 tryAgain:
 846   /* try for gpr type */
 847   if ((reg = allocReg (REG_GPR)))
 848     return reg;
 849
 850   if (!mcs51_ptrRegReq)
 851     if ((reg = allocReg (REG_PTR)))
 852       return reg;
 853
 854   /* we have to spil */
 855   if (!spilSomething (ic, ebp, sym))
 856     return NULL;
 857
 858   /* make sure partially assigned registers aren't reused */
 859   for (j=0; j<=sym->nRegs; j++)
 860     if (sym->regs[j])
 861       sym->regs[j]->isFree = 0;
 862
 863   /* this looks like an infinite loop but
 864      in really selectSpil will abort  */
 865   goto tryAgain;
 866 }
 867
 868 /*-----------------------------------------------------------------*/
 869 /* getRegPtrNoSpil - get it cannot split                           */
 870 /*-----------------------------------------------------------------*/
 871 static regs *getRegPtrNoSpil()
 872 {
 873   regs *reg;
 874
 875   /* try for a ptr type */
 876   if ((reg = allocReg (REG_PTR)))
 877     return reg;
 878
 879   /* try for gpr type */
 880   if ((reg = allocReg (REG_GPR)))
 881     return reg;
 882
 883   assert(0);
 884
 885   /* just to make the compiler happy */
 886   return 0;
 887 }
 888
 889 /*-----------------------------------------------------------------*/
 890 /* getRegGprNoSpil - get it cannot split                           */
 891 /*-----------------------------------------------------------------*/
 892 static regs *getRegGprNoSpil()
 893 {
 894
 895   regs *reg;
 896   if ((reg = allocReg (REG_GPR)))
 897     return reg;
 898
 899   if (!mcs51_ptrRegReq)
 900     if ((reg = allocReg (REG_PTR)))
 901       return reg;
 902
 903   assert(0);
 904
 905   /* just to make the compiler happy */
 906   return 0;
 907 }
 908
 909 /*-----------------------------------------------------------------*/
 910 /* symHasReg - symbol has a given register                         */
 911 /*-----------------------------------------------------------------*/
 912 static bool
 913 symHasReg (symbol * sym, regs * reg)
 914 {
 915   int i;
 916
 917   for (i = 0; i < sym->nRegs; i++)
 918     if (sym->regs[i] == reg)
 919       return TRUE;
 920
 921   return FALSE;
 922 }
 923
 924 /*-----------------------------------------------------------------*/
 925 /* deassignLRs - check the live to and if they have registers & are */
 926 /*               not spilt then free up the registers              */
 927 /*-----------------------------------------------------------------*/
 928 static void
 929 deassignLRs (iCode * ic, eBBlock * ebp)
 930 {
 931   symbol *sym;
 932   int k;
 933   symbol *result;
 934
 935   for (sym = hTabFirstItem (liveRanges, &k); sym;
 936        sym = hTabNextItem (liveRanges, &k))
 937     {
 938
 939       symbol *psym = NULL;
 940       /* if it does not end here */
 941       if (sym->liveTo > ic->seq)
 942         continue;
 943
 944       /* if it was spilt on stack then we can
 945          mark the stack spil location as free */
 946       if (sym->isspilt)
 947         {
 948           if (sym->stackSpil)
 949             {
 950               sym->usl.spillLoc->isFree = 1;
 951               sym->stackSpil = 0;
 952             }
 953           continue;
 954         }
 955
 956       if (!bitVectBitValue (_G.regAssigned, sym->key))
 957         continue;
 958
 959       /* special case check if this is an IFX &
 960          the privious one was a pop and the
 961          previous one was not spilt then keep track
 962          of the symbol */
 963       if (ic->op == IFX && ic->prev &&
 964           ic->prev->op == IPOP &&
 965           !ic->prev->parmPush &&
 966           !OP_SYMBOL (IC_LEFT (ic->prev))->isspilt)
 967         psym = OP_SYMBOL (IC_LEFT (ic->prev));
 968
 969       if (sym->nRegs)
 970         {
 971           int i = 0;
 972
 973           bitVectUnSetBit (_G.regAssigned, sym->key);
 974
 975           /* if the result of this one needs registers
 976              and does not have it then assign it right
 977              away */
 978           if (IC_RESULT (ic) &&
 979               !(SKIP_IC2 (ic) ||        /* not a special icode */
 980                 ic->op == JUMPTABLE ||
 981                 ic->op == IFX ||
 982                 ic->op == IPUSH ||
 983                 ic->op == IPOP ||
 984                 ic->op == RETURN ||
 985                 POINTER_SET (ic)) &&
 986               (result = OP_SYMBOL (IC_RESULT (ic))) &&  /* has a result */
 987               result->liveTo > ic->seq &&       /* and will live beyond this */
 988               result->liveTo <= ebp->lSeq &&    /* does not go beyond this block */
 989               result->liveFrom == ic->seq &&    /* does not start before here */
 990               result->regType == sym->regType &&        /* same register types */
 991               result->nRegs &&  /* which needs registers */
 992               !result->isspilt &&       /* and does not already have them */
 993               !result->remat &&
 994               !bitVectBitValue (_G.regAssigned, result->key) &&
 995           /* the number of free regs + number of regs in this LR
 996              can accomodate the what result Needs */
 997               ((nfreeRegsType (result->regType) +
 998                 sym->nRegs) >= result->nRegs)
 999             )
1000             {
1001
1002               for (i = 0; i < result->nRegs; i++)
1003                 if (i < sym->nRegs)
1004                   result->regs[i] = sym->regs[i];
1005                 else
1006                   result->regs[i] = getRegGpr (ic, ebp, result);
1007
1008               _G.regAssigned = bitVectSetBit (_G.regAssigned, result->key);
1009               _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, result->key);
1010
1011             }
1012
1013           /* free the remaining */
1014           for (; i < sym->nRegs; i++)
1015             {
1016               if (psym)
1017                 {
1018                   if (!symHasReg (psym, sym->regs[i]))
1019                     freeReg (sym->regs[i]);
1020                 }
1021               else
1022                 freeReg (sym->regs[i]);
1023             }
1024         }
1025     }
1026 }
1027
1028
1029 /*-----------------------------------------------------------------*/
1030 /* reassignLR - reassign this to registers                         */
1031 /*-----------------------------------------------------------------*/
1032 static void
1033 reassignLR (operand * op)
1034 {
1035   symbol *sym = OP_SYMBOL (op);
1036   int i;
1037
1038   /* not spilt any more */
1039   sym->isspilt = sym->spillA = sym->blockSpil = sym->remainSpil = 0;
1040   bitVectUnSetBit (_G.spiltSet, sym->key);
1041
1042   _G.regAssigned = bitVectSetBit (_G.regAssigned, sym->key);
1043   _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, sym->key);
1044
1045   _G.blockSpil--;
1046
1047   for (i = 0; i < sym->nRegs; i++)
1048     sym->regs[i]->isFree = 0;
1049 }
1050
1051 /*-----------------------------------------------------------------*/
1052 /* willCauseSpill - determines if allocating will cause a spill    */
1053 /*-----------------------------------------------------------------*/
1054 static int
1055 willCauseSpill (int nr, int rt)
1056 {
1057   /* first check if there are any avlb registers
1058      of te type required */
1059   if (rt == REG_PTR)
1060     {
1061       /* special case for pointer type
1062          if pointer type not avlb then
1063          check for type gpr */
1064       if (nFreeRegs (rt) >= nr)
1065         return 0;
1066       if (nFreeRegs (REG_GPR) >= nr)
1067         return 0;
1068     }
1069   else
1070     {
1071       if (mcs51_ptrRegReq)
1072         {
1073           if (nFreeRegs (rt) >= nr)
1074             return 0;
1075         }
1076       else
1077         {
1078           if (nFreeRegs (REG_PTR) +
1079               nFreeRegs (REG_GPR) >= nr)
1080             return 0;
1081         }
1082     }
1083
1084   /* it will cause a spil */
1085   return 1;
1086 }
1087
1088 /*-----------------------------------------------------------------*/
1089 /* positionRegs - the allocator can allocate same registers to res- */
1090 /* ult and operand, if this happens make sure they are in the same */
1091 /* position as the operand otherwise chaos results                 */
1092 /*-----------------------------------------------------------------*/
1093 static int
1094 positionRegs (symbol * result, symbol * opsym)
1095 {
1096   int count = min (result->nRegs, opsym->nRegs);
1097   int i, j = 0, shared = 0;
1098   int change = 0;
1099
1100   /* if the result has been spilt then cannot share */
1101   if (opsym->isspilt)
1102     return 0;
1103 again:
1104   shared = 0;
1105   /* first make sure that they actually share */
1106   for (i = 0; i < count; i++)
1107     {
1108       for (j = 0; j < count; j++)
1109         {
1110           if (result->regs[i] == opsym->regs[j] && i != j)
1111             {
1112               shared = 1;
1113               goto xchgPositions;
1114             }
1115         }
1116     }
1117 xchgPositions:
1118   if (shared)
1119     {
1120       regs *tmp = result->regs[i];
1121       result->regs[i] = result->regs[j];
1122       result->regs[j] = tmp;
1123       change ++;
1124       goto again;
1125     }
1126   return change;
1127 }
1128
1129 /*------------------------------------------------------------------*/
1130 /* verifyRegsAssigned - make sure an iTemp is properly initialized; */
1131 /* it should either have registers or have beed spilled. Otherwise, */
1132 /* there was an uninitialized variable, so just spill this to get   */
1133 /* the operand in a valid state.                                    */
1134 /*------------------------------------------------------------------*/
1135 static void
1136 verifyRegsAssigned (operand *op, iCode * ic)
1137 {
1138   symbol * sym;
1139
1140   if (!op) return;
1141   if (!IS_ITEMP (op)) return;
1142
1143   sym = OP_SYMBOL (op);
1144   if (sym->isspilt) return;
1145   if (!sym->nRegs) return;
1146   if (sym->regs[0]) return;
1147
1148   werrorfl (ic->filename, ic->lineno, W_LOCAL_NOINIT,
1149             sym->prereqv ? sym->prereqv->name : sym->name);
1150   spillThis (sym);
1151 }
1152
1153
1154 /*-----------------------------------------------------------------*/
1155 /* serialRegAssign - serially allocate registers to the variables  */
1156 /*-----------------------------------------------------------------*/
1157 static void
1158 serialRegAssign (eBBlock ** ebbs, int count)
1159 {
1160   int i;
1161
1162   /* for all blocks */
1163   for (i = 0; i < count; i++)
1164     {
1165
1166       iCode *ic;
1167
1168       if (ebbs[i]->noPath &&
1169           (ebbs[i]->entryLabel != entryLabel &&
1170            ebbs[i]->entryLabel != returnLabel))
1171         continue;
1172
1173       /* for all instructions do */
1174       for (ic = ebbs[i]->sch; ic; ic = ic->next)
1175         {
1176 #if 1
1177             int reg;
1178
1179             // update the registers in use at the start of this icode
1180             for (reg=0; reg<mcs51_nRegs; reg++) {
1181               if (regs8051[reg].isFree) {
1182                 ic->riu &= ~(1<<regs8051[reg].offset);
1183               } else {
1184                 ic->riu |= (1<<regs8051[reg].offset);
1185               }
1186             }
1187 #endif
1188             /* if this is an ipop that means some live
1189                range will have to be assigned again */
1190             if (ic->op == IPOP)
1191                 reassignLR (IC_LEFT (ic));
1192
1193             /* if result is present && is a true symbol */
1194             if (IC_RESULT (ic) && ic->op != IFX &&
1195                 IS_TRUE_SYMOP (IC_RESULT (ic)))
1196                 OP_SYMBOL (IC_RESULT (ic))->allocreq++;
1197
1198             /* take away registers from live
1199                ranges that end at this instruction */
1200             deassignLRs (ic, ebbs[i]);
1201
1202             /* some don't need registers */
1203             if (SKIP_IC2 (ic) ||
1204                 ic->op == JUMPTABLE ||
1205                 ic->op == IFX ||
1206                 ic->op == IPUSH ||
1207                 ic->op == IPOP ||
1208                 (IC_RESULT (ic) && POINTER_SET (ic)))
1209                 continue;
1210
1211             /* now we need to allocate registers
1212                only for the result */
1213             if (IC_RESULT (ic)) {
1214                 symbol *sym = OP_SYMBOL (IC_RESULT (ic));
1215                 bitVect *spillable;
1216                 int willCS;
1217                 int j;
1218                 int ptrRegSet = 0;
1219
1220                 /* if it does not need or is spilt
1221                    or is already assigned to registers
1222                    or will not live beyond this instructions */
1223                 if (!sym->nRegs ||
1224                     sym->isspilt ||
1225                     bitVectBitValue (_G.regAssigned, sym->key) ||
1226                     sym->liveTo <= ic->seq)
1227                     continue;
1228
1229                 /* if some liverange has been spilt at the block level
1230                    and this one live beyond this block then spil this
1231                    to be safe */
1232                 if (_G.blockSpil && sym->liveTo > ebbs[i]->lSeq) {
1233                     spillThis (sym);
1234                     continue;
1235                 }
1236
1237                 /* if this is a bit variable then don't use precious registers
1238                    along with expensive bit-to-char conversions but just spill
1239                    it */
1240                 if (SPEC_NOUN(sym->etype) == V_BIT) {
1241                     spillThis (sym);
1242                     continue;
1243                 }
1244
1245                 /* if trying to allocate this will cause
1246                    a spill and there is nothing to spill
1247                    or this one is rematerializable then
1248                    spill this one */
1249                 willCS = willCauseSpill (sym->nRegs, sym->regType);
1250                 spillable = computeSpillable (ic);
1251                 if (sym->remat || (willCS && bitVectIsZero (spillable))) {
1252                     spillThis (sym);
1253                     continue;
1254                 }
1255
1256                 /* If the live range preceeds the point of definition
1257                    then ideally we must take into account registers that
1258                    have been allocated after sym->liveFrom but freed
1259                    before ic->seq. This is complicated, so spill this
1260                    symbol instead and let fillGaps handle the allocation. */
1261                 if (sym->liveFrom < ic->seq) {
1262                     spillThis (sym);
1263                     continue;
1264                 }
1265
1266                 /* if it has a spillocation & is used less than
1267                    all other live ranges then spill this */
1268                 if (willCS) {
1269                     if (sym->usl.spillLoc) {
1270                         symbol *leastUsed = leastUsedLR (liveRangesWith (spillable,
1271                                                                          allLRs, ebbs[i], ic));
1272                         if (leastUsed && leastUsed->used > sym->used) {
1273                             spillThis (sym);
1274                             continue;
1275                         }
1276                     } else {
1277                         /* if none of the liveRanges have a spillLocation then better
1278                            to spill this one than anything else already assigned to registers */
1279                         if (liveRangesWith(spillable,noSpilLoc,ebbs[i],ic)) {
1280                             /* if this is local to this block then we might find a block spil */
1281                             if (!(sym->liveFrom >= ebbs[i]->fSeq && sym->liveTo <= ebbs[i]->lSeq)) {
1282                                 spillThis (sym);
1283                                 continue;
1284                             }
1285                         }
1286                     }
1287                 }
1288                 /* if we need ptr regs for the right side
1289                    then mark it */
1290                 if (POINTER_GET (ic) && IS_SYMOP (IC_LEFT (ic))
1291                     && getSize (OP_SYMBOL (IC_LEFT (ic))->type) <= (unsigned int) PTRSIZE) {
1292                     mcs51_ptrRegReq++;
1293                     ptrRegSet = 1;
1294                 }
1295                 if (IC_LEFT (ic) && IS_SYMOP (IC_LEFT (ic))
1296                     && SPEC_OCLS(OP_SYMBOL (IC_LEFT (ic))->etype) == idata) {
1297                     mcs51_ptrRegReq++;
1298                     ptrRegSet = 1;
1299                 }
1300                 if (IC_RIGHT (ic) && IS_SYMOP (IC_RIGHT (ic))
1301                     && SPEC_OCLS(OP_SYMBOL (IC_RIGHT (ic))->etype) == idata) {
1302                     mcs51_ptrRegReq++;
1303                     ptrRegSet = 1;
1304                 }
1305
1306                 /* else we assign registers to it */
1307                 _G.regAssigned = bitVectSetBit (_G.regAssigned, sym->key);
1308                 _G.totRegAssigned = bitVectSetBit (_G.totRegAssigned, sym->key);
1309
1310                 for (j = 0; j < sym->nRegs; j++) {
1311                     sym->regs[j] = NULL;
1312                     if (sym->regType == REG_PTR)
1313                         sym->regs[j] = getRegPtr (ic, ebbs[i], sym);
1314                     else
1315                       {
1316                         if (ic->op == CAST && IS_SYMOP (IC_RIGHT (ic)))
1317                           {
1318                             symbol * right = OP_SYMBOL (IC_RIGHT (ic));
1319
1320                             if (right->regs[j])
1321                               sym->regs[j] = allocThisReg (right->regs[j]);
1322                           }
1323                         if (!sym->regs[j])
1324                           sym->regs[j] = getRegGpr (ic, ebbs[i], sym);
1325                       }
1326
1327                     /* if the allocation failed which means
1328                        this was spilt then break */
1329                     if (!sym->regs[j])
1330                       {
1331                         for (i=0; i < sym->nRegs ; i++ )
1332                           sym->regs[i] = NULL;
1333                         break;
1334                       }
1335                 }
1336
1337                 if (!POINTER_SET(ic) && !POINTER_GET(ic)) {
1338                     /* if it shares registers with operands make sure
1339                        that they are in the same position */
1340                     if (IC_LEFT (ic) && IS_SYMOP (IC_LEFT (ic)) &&
1341                         OP_SYMBOL (IC_LEFT (ic))->nRegs) {
1342                         positionRegs (OP_SYMBOL (IC_RESULT (ic)),
1343                                       OP_SYMBOL (IC_LEFT (ic)));
1344                     }
1345                     /* do the same for the right operand */
1346                     if (IC_RIGHT (ic) && IS_SYMOP (IC_RIGHT (ic)) &&
1347                         OP_SYMBOL (IC_RIGHT (ic))->nRegs) {
1348                         positionRegs (OP_SYMBOL (IC_RESULT (ic)),
1349                                       OP_SYMBOL (IC_RIGHT (ic)));
1350                     }
1351                 }
1352
1353                 if (ptrRegSet) {
1354                     mcs51_ptrRegReq--;
1355                     ptrRegSet = 0;
1356                 }
1357
1358             }
1359         }
1360     }
1361
1362     /* Check for and fix any problems with uninitialized operands */
1363     for (i = 0; i < count; i++)
1364       {
1365         iCode *ic;
1366
1367         if (ebbs[i]->noPath &&
1368             (ebbs[i]->entryLabel != entryLabel &&
1369              ebbs[i]->entryLabel != returnLabel))
1370             continue;
1371
1372         for (ic = ebbs[i]->sch; ic; ic = ic->next)
1373           {
1374             if (SKIP_IC2 (ic))
1375               continue;
1376
1377             if (ic->op == IFX)
1378               {
1379                 verifyRegsAssigned (IC_COND (ic), ic);
1380                 continue;
1381               }
1382
1383             if (ic->op == JUMPTABLE)
1384               {
1385                 verifyRegsAssigned (IC_JTCOND (ic), ic);
1386                 continue;
1387               }
1388
1389             verifyRegsAssigned (IC_RESULT (ic), ic);
1390             verifyRegsAssigned (IC_LEFT (ic), ic);
1391             verifyRegsAssigned (IC_RIGHT (ic), ic);
1392           }
1393       }
1394 }
1395
1396 /*-----------------------------------------------------------------*/
1397 /* fillGaps - Try to fill in the Gaps left by Pass1                */
1398 /*-----------------------------------------------------------------*/
1399 static void fillGaps()
1400 {
1401     symbol *sym =NULL;
1402     int key =0;
1403     int pass;
1404     iCode *ic = NULL;
1405
1406     if (getenv("DISABLE_FILL_GAPS")) return;
1407
1408     /* look for liveranges that were spilt by the allocator */
1409     for (sym = hTabFirstItem(liveRanges,&key) ; sym ;
1410          sym = hTabNextItem(liveRanges,&key)) {
1411
1412         int i;
1413         int pdone = 0;
1414
1415         if (!sym->spillA || !sym->clashes || sym->remat) continue ;
1416
1417         /* find the liveRanges this one clashes with, that are
1418            still assigned to registers & mark the registers as used*/
1419         for ( i = 0 ; i < sym->clashes->size ; i ++) {
1420             int k;
1421             symbol *clr;
1422
1423             if (bitVectBitValue(sym->clashes,i) == 0 ||    /* those that clash with this */
1424                 bitVectBitValue(_G.totRegAssigned,i) == 0) /* and are still assigned to registers */
1425                 continue ;
1426
1427             clr = hTabItemWithKey(liveRanges,i);
1428             assert(clr);
1429
1430             /* mark these registers as used */
1431             for (k = 0 ; k < clr->nRegs ; k++ )
1432                 useReg(clr->regs[k]);
1433         }
1434
1435         if (willCauseSpill(sym->nRegs,sym->regType)) {
1436             /* NOPE :( clear all registers & and continue */
1437             freeAllRegs();
1438             continue ;
1439         }
1440
1441         ic = NULL;
1442         for (i = 0 ; i < sym->defs->size ; i++ )
1443           {
1444             if (bitVectBitValue(sym->defs,i))
1445               {
1446                 if (!(ic = hTabItemWithKey(iCodehTab,i)))
1447                   continue;
1448                 if (ic->op == CAST)
1449                   break;
1450               }
1451           }
1452
1453         D(printf("Atemping fillGaps on %s: [",sym->name));
1454         /* THERE IS HOPE !!!! */
1455         for (i=0; i < sym->nRegs ; i++ ) {
1456             if (sym->regType == REG_PTR)
1457                 sym->regs[i] = getRegPtrNoSpil ();
1458             else
1459               {
1460                 sym->regs[i] = NULL;
1461                 if (ic && ic->op == CAST && IS_SYMOP (IC_RIGHT (ic)))
1462                   {
1463                     symbol * right = OP_SYMBOL (IC_RIGHT (ic));
1464
1465                     if (right->regs[i])
1466                       sym->regs[i] = allocThisReg (right->regs[i]);
1467                   }
1468                 if (!sym->regs[i])
1469                   sym->regs[i] = getRegGprNoSpil ();
1470               }
1471             D(printf("%s ", sym->regs[i]->name));
1472         }
1473         D(printf("]\n"));
1474
1475         /* For all its definitions check if the registers
1476            allocated needs positioning NOTE: we can position
1477            only ONCE if more than One positioning required
1478            then give up.
1479            We may need to perform the checks twice; once to
1480            position the registers as needed, the second to
1481            verify any register repositioning is still
1482            compatible.
1483           */
1484         sym->isspilt = 0;
1485         for (pass=0; pass<2; pass++) {
1486             D(printf(" checking definitions\n"));
1487             for (i = 0 ; i < sym->defs->size ; i++ ) {
1488                 if (bitVectBitValue(sym->defs,i)) {
1489                     if (!(ic = hTabItemWithKey(iCodehTab,i))) continue ;
1490                     D(printf("  ic->seq = %d\n", ic->seq));
1491                     if (SKIP_IC(ic)) continue;
1492                     assert(isSymbolEqual(sym,OP_SYMBOL(IC_RESULT(ic)))); /* just making sure */
1493                     /* if left is assigned to registers */
1494                     if (IS_SYMOP(IC_LEFT(ic)))
1495                       {
1496                         D(printf("   left = "));
1497                         D(printOperand(IC_LEFT(ic),NULL));
1498                       }
1499                     if (IS_SYMOP(IC_LEFT(ic)) &&
1500                       bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_LEFT(ic))->key)) {
1501                         pdone += (positionRegs(sym,OP_SYMBOL(IC_LEFT(ic)))>0);
1502                     }
1503                     if (IS_SYMOP(IC_RIGHT(ic)))
1504                       {
1505                         D(printf("   right = "));
1506                         D(printOperand(IC_RIGHT(ic),NULL));
1507                       }
1508                     if (IS_SYMOP(IC_RIGHT(ic)) &&
1509                       bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_RIGHT(ic))->key)) {
1510                         pdone += (positionRegs(sym,OP_SYMBOL(IC_RIGHT(ic)))>0);
1511                     }
1512                     D(printf("   pdone = %d\n", pdone));
1513                     if (pdone > 1) break;
1514                 }
1515             }
1516             D(printf(" checking uses\n"));
1517             for (i = 0 ; i < sym->uses->size ; i++ ) {
1518                 if (bitVectBitValue(sym->uses,i)) {
1519                     iCode *ic;
1520                     if (!(ic = hTabItemWithKey(iCodehTab,i))) continue ;
1521                     D(printf("  ic->seq = %d\n", ic->seq));
1522                     if (SKIP_IC(ic)) continue;
1523                     if (POINTER_SET(ic) || POINTER_GET(ic)) continue ;
1524
1525                     /* if result is assigned to registers */
1526                     if (IS_SYMOP(IC_RESULT(ic)))
1527                       {
1528                         D(printf("   result = "));
1529                         D(printOperand(IC_RESULT(ic),NULL));
1530                       }
1531                     if (IS_SYMOP(IC_RESULT(ic)) &&
1532                         bitVectBitValue(_G.totRegAssigned,OP_SYMBOL(IC_RESULT(ic))->key)) {
1533                         pdone += (positionRegs(sym,OP_SYMBOL(IC_RESULT(ic)))>0);
1534                     }
1535                     D(printf("   pdone = %d\n", pdone));
1536                     if (pdone > 1) break;
1537                 }
1538             }
1539             if (pdone == 0) break; /* second pass only if regs repositioned */
1540             if (pdone > 1) break;
1541         }
1542         D(printf(" sym->regs = ["));
1543         for (i=0; i < sym->nRegs ; i++ )
1544           D(printf("%s ", sym->regs[i]->name));
1545         D(printf("]\n"));
1546         /* had to position more than once GIVE UP */
1547         if (pdone > 1) {
1548             /* UNDO all the changes we made to try this */
1549             sym->isspilt = 1;
1550             for (i=0; i < sym->nRegs ; i++ ) {
1551                     sym->regs[i] = NULL;
1552             }
1553             freeAllRegs();
1554             D(printf ("Fill Gap gave up due to positioning for %s in function %s\n",sym->name, currFunc ? currFunc->name : "UNKNOWN"));
1555             continue ;
1556         }
1557         D(printf ("FILLED GAP for %s in function %s\n",sym->name, currFunc ? currFunc->name : "UNKNOWN"));
1558
1559         _G.totRegAssigned = bitVectSetBit(_G.totRegAssigned,sym->key);
1560         sym->isspilt = sym->spillA = 0 ;
1561         sym->usl.spillLoc->allocreq--;
1562         freeAllRegs();
1563     }
1564 }
1565
1566 /*-----------------------------------------------------------------*/
1567 /* rUmaskForOp :- returns register mask for an operand             */
1568 /*-----------------------------------------------------------------*/
1569 bitVect *
1570 mcs51_rUmaskForOp (operand * op)
1571 {
1572   bitVect *rumask;
1573   symbol *sym;
1574   int j;
1575
1576   /* only temporaries are assigned registers */
1577   if (!IS_ITEMP (op))
1578     return NULL;
1579
1580   sym = OP_SYMBOL (op);
1581
1582   /* if spilt or no registers assigned to it
1583      then nothing */
1584   if (sym->isspilt || !sym->nRegs)
1585     return NULL;
1586
1587   rumask = newBitVect (mcs51_nRegs);
1588
1589   for (j = 0; j < sym->nRegs; j++)
1590     {
1591       if (sym->regs[j]) /* EEP - debug */
1592         rumask = bitVectSetBit (rumask, sym->regs[j]->rIdx);
1593     }
1594
1595   return rumask;
1596 }
1597
1598 /*-----------------------------------------------------------------*/
1599 /* regsUsedIniCode :- returns bit vector of registers used in iCode */
1600 /*-----------------------------------------------------------------*/
1601 static bitVect *
1602 regsUsedIniCode (iCode * ic)
1603 {
1604   bitVect *rmask = newBitVect (mcs51_nRegs);
1605
1606   /* do the special cases first */
1607   if (ic->op == IFX)
1608     {
1609       rmask = bitVectUnion (rmask,
1610                             mcs51_rUmaskForOp (IC_COND (ic)));
1611       goto ret;
1612     }
1613
1614   /* for the jumptable */
1615   if (ic->op == JUMPTABLE)
1616     {
1617       rmask = bitVectUnion (rmask,
1618                             mcs51_rUmaskForOp (IC_JTCOND (ic)));
1619
1620       goto ret;
1621     }
1622
1623   /* of all other cases */
1624   if (IC_LEFT (ic))
1625     rmask = bitVectUnion (rmask,
1626                           mcs51_rUmaskForOp (IC_LEFT (ic)));
1627
1628
1629   if (IC_RIGHT (ic))
1630     rmask = bitVectUnion (rmask,
1631                           mcs51_rUmaskForOp (IC_RIGHT (ic)));
1632
1633   if (IC_RESULT (ic))
1634     rmask = bitVectUnion (rmask,
1635                           mcs51_rUmaskForOp (IC_RESULT (ic)));
1636
1637 ret:
1638   return rmask;
1639 }
1640
1641 /*-----------------------------------------------------------------*/
1642 /* createRegMask - for each instruction will determine the regsUsed */
1643 /*-----------------------------------------------------------------*/
1644 static void
1645 createRegMask (eBBlock ** ebbs, int count)
1646 {
1647   int i;
1648
1649   /* for all blocks */
1650   for (i = 0; i < count; i++)
1651     {
1652       iCode *ic;
1653
1654       if (ebbs[i]->noPath &&
1655           (ebbs[i]->entryLabel != entryLabel &&
1656            ebbs[i]->entryLabel != returnLabel))
1657         continue;
1658
1659       /* for all instructions */
1660       for (ic = ebbs[i]->sch; ic; ic = ic->next)
1661         {
1662
1663           int j;
1664
1665           if (SKIP_IC2 (ic) || !ic->rlive)
1666             continue;
1667
1668           /* first mark the registers used in this
1669              instruction */
1670           ic->rUsed = regsUsedIniCode (ic);
1671           _G.funcrUsed = bitVectUnion (_G.funcrUsed, ic->rUsed);
1672
1673           /* now create the register mask for those
1674              registers that are in use : this is a
1675              super set of ic->rUsed */
1676           ic->rMask = newBitVect (mcs51_nRegs + 1);
1677
1678           /* for all live Ranges alive at this point */
1679           for (j = 1; j < ic->rlive->size; j++)
1680             {
1681               symbol *sym;
1682               int k;
1683
1684               /* if not alive then continue */
1685               if (!bitVectBitValue (ic->rlive, j))
1686                 continue;
1687
1688               /* find the live range we are interested in */
1689               if (!(sym = hTabItemWithKey (liveRanges, j)))
1690                 {
1691                   werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
1692                           "createRegMask cannot find live range");
1693                   fprintf(stderr, "\tmissing live range: key=%d\n", j);
1694                   exit (0);
1695                 }
1696
1697               /* if no register assigned to it */
1698               if (!sym->nRegs || sym->isspilt)
1699                 continue;
1700
1701               /* for all the registers allocated to it */
1702               for (k = 0; k < sym->nRegs; k++)
1703                 if (sym->regs[k])
1704                   ic->rMask =
1705                     bitVectSetBit (ic->rMask, sym->regs[k]->rIdx);
1706             }
1707         }
1708     }
1709 }
1710
1711 /*-----------------------------------------------------------------*/
1712 /* rematStr - returns the rematerialized string for a remat var    */
1713 /*-----------------------------------------------------------------*/
1714 static char *
1715 rematStr (symbol * sym)
1716 {
1717   char *s = buffer;
1718   iCode *ic = sym->rematiCode;
1719
1720   *s = 0;
1721
1722   while (1)
1723     {
1724
1725       /* if plus or minus print the right hand side */
1726       if (ic->op == '+' || ic->op == '-')
1727         {
1728           SNPRINTF (s, sizeof(buffer) - strlen(buffer),
1729                     "0x%04x %c ", (int) operandLitValue (IC_RIGHT (ic)),
1730                     ic->op);
1731           s += strlen (s);
1732           ic = OP_SYMBOL (IC_LEFT (ic))->rematiCode;
1733           continue;
1734         }
1735
1736       /* cast then continue */
1737       if (IS_CAST_ICODE(ic)) {
1738           ic = OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
1739           continue;
1740       }
1741       /* we reached the end */
1742       SNPRINTF (s, sizeof(buffer) - strlen(buffer),
1743                 "%s", OP_SYMBOL (IC_LEFT (ic))->rname);
1744       break;
1745     }
1746
1747   return buffer;
1748 }
1749
1750 /*-----------------------------------------------------------------*/
1751 /* regTypeNum - computes the type & number of registers required   */
1752 /*-----------------------------------------------------------------*/
1753 static void
1754 regTypeNum (eBBlock *ebbs)
1755 {
1756   symbol *sym;
1757   int k;
1758   iCode *ic;
1759
1760   /* for each live range do */
1761   for (sym = hTabFirstItem (liveRanges, &k); sym;
1762        sym = hTabNextItem (liveRanges, &k))
1763     {
1764
1765       /* if used zero times then no registers needed */
1766       if ((sym->liveTo - sym->liveFrom) == 0)
1767         continue;
1768
1769
1770       /* if the live range is a temporary */
1771       if (sym->isitmp)
1772         {
1773
1774           /* if the type is marked as a conditional */
1775           if (sym->regType == REG_CND)
1776             continue;
1777
1778           /* if used in return only then we don't
1779              need registers */
1780           if (sym->ruonly || sym->accuse)
1781             {
1782               if (IS_AGGREGATE (sym->type) || sym->isptr)
1783                 sym->type = aggrToPtr (sym->type, FALSE);
1784               continue;
1785             }
1786
1787           /* if the symbol has only one definition &
1788              that definition is a get_pointer */
1789           if (bitVectnBitsOn (sym->defs) == 1 &&
1790               (ic = hTabItemWithKey (iCodehTab,
1791                                      bitVectFirstBit (sym->defs))) &&
1792               POINTER_GET (ic) &&
1793               !IS_BITVAR (sym->etype) &&
1794               (aggrToPtrDclType (operandType (IC_LEFT (ic)), FALSE) == POINTER))
1795             {
1796
1797               if (ptrPseudoSymSafe (sym, ic))
1798                 {
1799                   ptrPseudoSymConvert (sym, ic, rematStr (OP_SYMBOL (IC_LEFT (ic))));
1800                   continue;
1801                 }
1802
1803               /* if in data space or idata space then try to
1804                  allocate pointer register */
1805
1806             }
1807
1808           /* if not then we require registers */
1809           sym->nRegs = ((IS_AGGREGATE (sym->type) || sym->isptr) ?
1810                         getSize (sym->type = aggrToPtr (sym->type, FALSE)) :
1811                         getSize (sym->type));
1812
1813           if (sym->nRegs > 4)
1814             {
1815               fprintf (stderr, "allocated more than 4 or 0 registers for type ");
1816               printTypeChain (sym->type, stderr);
1817               fprintf (stderr, "\n");
1818             }
1819
1820           /* determine the type of register required */
1821           if (sym->nRegs == 1 &&
1822               IS_PTR (sym->type) &&
1823               sym->uptr)
1824             sym->regType = REG_PTR;
1825           else
1826             sym->regType = REG_GPR;
1827
1828         }
1829       else
1830         /* for the first run we don't provide */
1831         /* registers for true symbols we will */
1832         /* see how things go                  */
1833         sym->nRegs = 0;
1834     }
1835
1836 }
1837
1838 /*-----------------------------------------------------------------*/
1839 /* freeAllRegs - mark all registers as free                        */
1840 /*-----------------------------------------------------------------*/
1841 static void
1842 freeAllRegs ()
1843 {
1844   int i;
1845
1846   for (i = 0; i < mcs51_nRegs; i++)
1847     regs8051[i].isFree = 1;
1848 }
1849
1850 /*-----------------------------------------------------------------*/
1851 /* deallocStackSpil - this will set the stack pointer back         */
1852 /*-----------------------------------------------------------------*/
1853 static
1854 DEFSETFUNC (deallocStackSpil)
1855 {
1856   symbol *sym = item;
1857
1858   deallocLocal (sym);
1859   return 0;
1860 }
1861
1862 /*-----------------------------------------------------------------*/
1863 /* farSpacePackable - returns the packable icode for far variables */
1864 /*-----------------------------------------------------------------*/
1865 static iCode *
1866 farSpacePackable (iCode * ic)
1867 {
1868   iCode *dic;
1869
1870   /* go thru till we find a definition for the
1871      symbol on the right */
1872   for (dic = ic->prev; dic; dic = dic->prev)
1873     {
1874       /* if the definition is a call then no */
1875       if ((dic->op == CALL || dic->op == PCALL) &&
1876           IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
1877         {
1878           return NULL;
1879         }
1880
1881       /* if shift by unknown amount then not */
1882       if ((dic->op == LEFT_OP || dic->op == RIGHT_OP) &&
1883           IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
1884         return NULL;
1885
1886       /* if pointer get and size > 1 */
1887       if (POINTER_GET (dic) &&
1888           getSize (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)) > 1)
1889         return NULL;
1890
1891       if (POINTER_SET (dic) &&
1892           getSize (aggrToPtr (operandType (IC_RESULT (dic)), FALSE)) > 1)
1893         return NULL;
1894
1895       if (dic->op == IFX)
1896         {
1897           if (IC_COND (dic) &&
1898               IS_TRUE_SYMOP (IC_COND (dic)) &&
1899               isOperandInFarSpace (IC_COND (dic)))
1900             return NULL;
1901         }
1902       else if (dic->op == JUMPTABLE)
1903         {
1904           if (IC_JTCOND (dic) &&
1905               IS_TRUE_SYMOP (IC_JTCOND (dic)) &&
1906               isOperandInFarSpace (IC_JTCOND (dic)))
1907             return NULL;
1908         }
1909       else
1910         {
1911           /* if any tree is a true symbol in far space */
1912           if (IC_RESULT (dic) &&
1913               IS_TRUE_SYMOP (IC_RESULT (dic)) &&
1914               isOperandInFarSpace (IC_RESULT (dic)))
1915             return NULL;
1916
1917           if (IC_RIGHT (dic) &&
1918               IS_TRUE_SYMOP (IC_RIGHT (dic)) &&
1919               isOperandInFarSpace (IC_RIGHT (dic)) &&
1920               !isOperandEqual (IC_RIGHT (dic), IC_RESULT (ic)))
1921             return NULL;
1922
1923           if (IC_LEFT (dic) &&
1924               IS_TRUE_SYMOP (IC_LEFT (dic)) &&
1925               isOperandInFarSpace (IC_LEFT (dic)) &&
1926               !isOperandEqual (IC_LEFT (dic), IC_RESULT (ic)))
1927             return NULL;
1928         }
1929
1930       if (isOperandEqual (IC_RIGHT (ic), IC_RESULT (dic)))
1931         {
1932           if ((dic->op == LEFT_OP ||
1933                dic->op == RIGHT_OP ||
1934                dic->op == '-') &&
1935               IS_OP_LITERAL (IC_RIGHT (dic)))
1936             return NULL;
1937           else
1938             return dic;
1939         }
1940     }
1941
1942   return NULL;
1943 }
1944
1945 /*-----------------------------------------------------------------*/
1946 /* packRegsForAssign - register reduction for assignment           */
1947 /*-----------------------------------------------------------------*/
1948 static int
1949 packRegsForAssign (iCode * ic, eBBlock * ebp)
1950 {
1951   iCode *dic, *sic;
1952
1953   if (!IS_ITEMP (IC_RIGHT (ic)) ||
1954       OP_SYMBOL (IC_RIGHT (ic))->isind ||
1955       OP_LIVETO (IC_RIGHT (ic)) > ic->seq)
1956     {
1957       return 0;
1958     }
1959
1960   /* if the true symbol is defined in far space or on stack
1961      then we should not since this will increase register pressure */
1962   if (isOperandInFarSpace(IC_RESULT(ic)) && !farSpacePackable(ic)) {
1963     return 0;
1964   }
1965
1966   /* find the definition of iTempNN scanning backwards if we find a
1967      a use of the true symbol in before we find the definition then
1968      we cannot */
1969   for (dic = ic->prev; dic; dic = dic->prev)
1970     {
1971       int crossedCall = 0;
1972
1973       /* We can pack across a function call only if it's a local */
1974       /* variable or our parameter. Never pack global variables */
1975       /* or parameters to a function we call. */
1976       if ((dic->op == CALL || dic->op == PCALL))
1977         {
1978           if (!OP_SYMBOL (IC_RESULT (ic))->ismyparm
1979               && !OP_SYMBOL (IC_RESULT (ic))->islocal)
1980             {
1981               crossedCall = 1;
1982             }
1983         }
1984
1985       if (SKIP_IC2 (dic))
1986         continue;
1987
1988       if (dic->op == IFX)
1989         {
1990           if (IS_SYMOP (IC_COND (dic)) &&
1991               (IC_COND (dic)->key == IC_RESULT (ic)->key ||
1992                IC_COND (dic)->key == IC_RIGHT (ic)->key))
1993             {
1994               dic = NULL;
1995               break;
1996             }
1997         }
1998       else
1999         {
2000           if (IS_TRUE_SYMOP (IC_RESULT (dic)) &&
2001               IS_OP_VOLATILE (IC_RESULT (dic)))
2002             {
2003               dic = NULL;
2004               break;
2005             }
2006
2007           if (IS_SYMOP (IC_RESULT (dic)) &&
2008               IC_RESULT (dic)->key == IC_RIGHT (ic)->key)
2009             {
2010               if (POINTER_SET (dic))
2011                 dic = NULL;
2012
2013               break;
2014             }
2015
2016           if (IS_SYMOP (IC_RIGHT (dic)) &&
2017               (IC_RIGHT (dic)->key == IC_RESULT (ic)->key ||
2018                IC_RIGHT (dic)->key == IC_RIGHT (ic)->key))
2019             {
2020               dic = NULL;
2021               break;
2022             }
2023
2024           if (IS_SYMOP (IC_LEFT (dic)) &&
2025               (IC_LEFT (dic)->key == IC_RESULT (ic)->key ||
2026                IC_LEFT (dic)->key == IC_RIGHT (ic)->key))
2027             {
2028               dic = NULL;
2029               break;
2030             }
2031
2032           if (IS_SYMOP (IC_RESULT (dic)) &&
2033               IC_RESULT (dic)->key == IC_RESULT (ic)->key)
2034             {
2035               dic = NULL;
2036               break;
2037             }
2038
2039           if (crossedCall)
2040             {
2041               dic = NULL;
2042               break;
2043             }
2044
2045         }
2046     }
2047
2048   if (!dic)
2049     return 0;                   /* did not find */
2050
2051   /* if assignment then check that right is not a bit */
2052   if (ASSIGNMENT (ic) && !POINTER_SET (ic))
2053     {
2054       sym_link *etype = operandType (IC_RESULT (dic));
2055       if (IS_BITFIELD (etype))
2056         {
2057           /* if result is a bit too then it's ok */
2058           etype = operandType (IC_RESULT (ic));
2059           if (!IS_BITFIELD (etype))
2060             {
2061               return 0;
2062             }
2063        }
2064     }
2065 #if 0
2066   /* if assignment then check that right is not a bit */
2067   if (ASSIGNMENT (dic) && !POINTER_SET (dic))
2068     {
2069       sym_link *etype = operandType (IC_RIGHT (dic));
2070       if (IS_BITFIELD (etype))
2071         {
2072           /* if result is a bit too then it's ok */
2073           etype = operandType (IC_RESULT (dic));
2074           if (!IS_BITFIELD (etype))
2075             return 0;
2076         }
2077     }
2078 #endif
2079   /* if the result is on stack or iaccess then it must be
2080      the same atleast one of the operands */
2081   if (OP_SYMBOL (IC_RESULT (ic))->onStack ||
2082       OP_SYMBOL (IC_RESULT (ic))->iaccess)
2083     {
2084
2085       /* the operation has only one symbol
2086          operator then we can pack */
2087       if ((IC_LEFT (dic) && !IS_SYMOP (IC_LEFT (dic))) ||
2088           (IC_RIGHT (dic) && !IS_SYMOP (IC_RIGHT (dic))))
2089         goto pack;
2090
2091       if (!((IC_LEFT (dic) &&
2092              IC_RESULT (ic)->key == IC_LEFT (dic)->key) ||
2093             (IC_RIGHT (dic) &&
2094              IC_RESULT (ic)->key == IC_RIGHT (dic)->key)))
2095         return 0;
2096     }
2097 pack:
2098   /* found the definition */
2099   /* replace the result with the result of */
2100   /* this assignment and remove this assignment */
2101   bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2102   ReplaceOpWithCheaperOp(&IC_RESULT (dic), IC_RESULT (ic));
2103
2104   if (IS_ITEMP (IC_RESULT (dic)) && OP_SYMBOL (IC_RESULT (dic))->liveFrom > dic->seq)
2105     {
2106       OP_SYMBOL (IC_RESULT (dic))->liveFrom = dic->seq;
2107     }
2108   // TODO: and the otherway around?
2109
2110   /* delete from liverange table also
2111      delete from all the points inbetween and the new
2112      one */
2113   for (sic = dic; sic != ic; sic = sic->next)
2114     {
2115       bitVectUnSetBit (sic->rlive, IC_RESULT (ic)->key);
2116       if (IS_ITEMP (IC_RESULT (dic)))
2117         bitVectSetBit (sic->rlive, IC_RESULT (dic)->key);
2118     }
2119
2120   remiCodeFromeBBlock (ebp, ic);
2121   bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
2122   hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
2123   OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
2124   return 1;
2125 }
2126
2127 /*------------------------------------------------------------------*/
2128 /* findAssignToSym : scanning backwards looks for first assig found */
2129 /*------------------------------------------------------------------*/
2130 static iCode *
2131 findAssignToSym (operand * op, iCode * ic)
2132 {
2133   iCode *dic;
2134
2135   /* This routine is used to find sequences like
2136      iTempAA = FOO;
2137      ...;  (intervening ops don't use iTempAA or modify FOO)
2138      blah = blah + iTempAA;
2139
2140      and eliminate the use of iTempAA, freeing up its register for
2141      other uses.
2142   */
2143
2144   for (dic = ic->prev; dic; dic = dic->prev)
2145     {
2146
2147       /* if definition by assignment */
2148       if (dic->op == '=' &&
2149           !POINTER_SET (dic) &&
2150           IC_RESULT (dic)->key == op->key
2151 /*          &&  IS_TRUE_SYMOP(IC_RIGHT(dic)) */
2152         )
2153         break;  /* found where this temp was defined */
2154
2155       /* if we find an usage then we cannot delete it */
2156
2157       if (dic->op == IFX)
2158         {
2159           if (IC_COND (dic) && IC_COND (dic)->key == op->key)
2160             return NULL;
2161         }
2162       else if (dic->op == JUMPTABLE)
2163         {
2164           if (IC_JTCOND (dic) && IC_JTCOND (dic)->key == op->key)
2165             return NULL;
2166         }
2167       else
2168         {
2169           if (IC_LEFT (dic) && IC_LEFT (dic)->key == op->key)
2170             return NULL;
2171
2172           if (IC_RIGHT (dic) && IC_RIGHT (dic)->key == op->key)
2173             return NULL;
2174
2175           if (POINTER_SET (dic) && IC_RESULT (dic)->key == op->key)
2176             return NULL;
2177         }
2178     }
2179
2180   if (!dic)
2181     return NULL;   /* didn't find any assignment to op */
2182
2183   /* we are interested only if defined in far space */
2184   /* or in stack space in case of + & - */
2185
2186   /* if assigned to a non-symbol then don't repack regs */
2187   if (!IS_SYMOP (IC_RIGHT (dic)))
2188     return NULL;
2189
2190   /* if the symbol is volatile then we should not */
2191   if (isOperandVolatile (IC_RIGHT (dic), TRUE))
2192     return NULL;
2193   /* XXX TODO --- should we be passing FALSE to isOperandVolatile()?
2194      What does it mean for an iTemp to be volatile, anyway? Passing
2195      TRUE is more cautious but may prevent possible optimizations */
2196
2197   /* if the symbol is in far space then we should not */
2198   if (isOperandInFarSpace (IC_RIGHT (dic)))
2199     return NULL;
2200
2201   /* for + & - operations make sure that
2202      if it is on the stack it is the same
2203      as one of the three operands */
2204   if ((ic->op == '+' || ic->op == '-') &&
2205       OP_SYMBOL (IC_RIGHT (dic))->onStack)
2206     {
2207
2208       if (IC_RESULT (ic)->key != IC_RIGHT (dic)->key &&
2209           IC_LEFT (ic)->key != IC_RIGHT (dic)->key &&
2210           IC_RIGHT (ic)->key != IC_RIGHT (dic)->key)
2211         return NULL;
2212     }
2213
2214   /* now make sure that the right side of dic
2215      is not defined between ic & dic */
2216   if (dic)
2217     {
2218       iCode *sic = dic->next;
2219
2220       for (; sic != ic; sic = sic->next)
2221         if (IC_RESULT (sic) &&
2222             IC_RESULT (sic)->key == IC_RIGHT (dic)->key)
2223           return NULL;
2224     }
2225
2226   return dic;
2227 }
2228
2229 /*-----------------------------------------------------------------*/
2230 /* reassignAliasedSym - used by packRegsForSupport to replace      */
2231 /*                      redundant iTemp with equivalent symbol     */
2232 /*-----------------------------------------------------------------*/
2233 static void
2234 reassignAliasedSym (eBBlock *ebp, iCode *assignment, iCode *use, operand *op)
2235 {
2236   iCode *ic;
2237   unsigned oldSymKey, newSymKey;
2238
2239   oldSymKey = op->key;
2240   newSymKey = IC_RIGHT(assignment)->key;
2241
2242   /* only track live ranges of compiler-generated temporaries */
2243   if (!IS_ITEMP(IC_RIGHT(assignment)))
2244     newSymKey = 0;
2245
2246   /* update the live-value bitmaps */
2247   for (ic = assignment; ic != use; ic = ic->next) {
2248     bitVectUnSetBit (ic->rlive, oldSymKey);
2249     if (newSymKey != 0)
2250       ic->rlive = bitVectSetBit (ic->rlive, newSymKey);
2251   }
2252
2253   /* update the sym of the used operand */
2254   OP_SYMBOL(op) = OP_SYMBOL(IC_RIGHT(assignment));
2255   op->key = OP_SYMBOL(op)->key;
2256   OP_SYMBOL(op)->accuse = 0;
2257
2258   /* update the sym's liverange */
2259   if ( OP_LIVETO(op) < ic->seq )
2260     setToRange(op, ic->seq, FALSE);
2261
2262   /* remove the assignment iCode now that its result is unused */
2263   remiCodeFromeBBlock (ebp, assignment);
2264   bitVectUnSetBit(OP_SYMBOL(IC_RESULT(assignment))->defs, assignment->key);
2265   hTabDeleteItem (&iCodehTab, assignment->key, assignment, DELETE_ITEM, NULL);
2266 }
2267
2268
2269 /*-----------------------------------------------------------------*/
2270 /* packRegsForSupport :- reduce some registers for support calls   */
2271 /*-----------------------------------------------------------------*/
2272 static int
2273 packRegsForSupport (iCode * ic, eBBlock * ebp)
2274 {
2275   iCode *dic;
2276
2277   /* for the left & right operand :- look to see if the
2278      left was assigned a true symbol in far space in that
2279      case replace them */
2280
2281   if (IS_ITEMP (IC_LEFT (ic)) &&
2282       OP_SYMBOL (IC_LEFT (ic))->liveTo <= ic->seq)
2283     {
2284       dic = findAssignToSym (IC_LEFT (ic), ic);
2285
2286       if (dic)
2287         {
2288           /* found it we need to remove it from the block */
2289           reassignAliasedSym (ebp, dic, ic, IC_LEFT(ic));
2290           return 1;
2291         }
2292     }
2293
2294   /* do the same for the right operand */
2295   if (IS_ITEMP (IC_RIGHT (ic)) &&
2296       OP_SYMBOL (IC_RIGHT (ic))->liveTo <= ic->seq)
2297     {
2298       iCode *dic = findAssignToSym (IC_RIGHT (ic), ic);
2299
2300       if (dic)
2301         {
2302           /* if this is a subtraction & the result
2303              is a true symbol in far space then don't pack */
2304           if (ic->op == '-' && IS_TRUE_SYMOP (IC_RESULT (dic)))
2305             {
2306               sym_link *etype = getSpec (operandType (IC_RESULT (dic)));
2307               if (IN_FARSPACE (SPEC_OCLS (etype)))
2308                 return 0;
2309             }
2310           /* found it we need to remove it from the
2311              block */
2312           reassignAliasedSym (ebp, dic, ic, IC_RIGHT(ic));
2313
2314           return 1;
2315         }
2316     }
2317
2318   return 0;
2319 }
2320
2321 #define IS_OP_RUONLY(x) (x && IS_SYMOP(x) && OP_SYMBOL(x)->ruonly)
2322
2323
2324 /*-----------------------------------------------------------------*/
2325 /* packRegsForOneuse : - will reduce some registers for single Use */
2326 /*-----------------------------------------------------------------*/
2327 static iCode *
2328 packRegsForOneuse (iCode * ic, operand * op, eBBlock * ebp)
2329 {
2330   iCode *dic, *sic;
2331
2332   /* if returning a literal then do nothing */
2333   if (!IS_ITEMP (op))
2334     return NULL;
2335
2336   /* if rematerializable or already return use then do nothing */
2337   if (OP_SYMBOL(op)->remat || OP_SYMBOL(op)->ruonly)
2338     return NULL;
2339
2340   /* only upto 2 bytes since we cannot predict
2341      the usage of b, & acc */
2342   if (getSize (operandType (op)) > (fReturnSizeMCS51 - 2))
2343     return NULL;
2344
2345   if (ic->op != RETURN &&
2346       ic->op != SEND &&
2347       !POINTER_SET (ic) &&
2348       !POINTER_GET (ic))
2349     return NULL;
2350
2351   if (ic->op == SEND && ic->argreg != 1) return NULL;
2352
2353   /* this routine will mark the a symbol as used in one
2354      instruction use only && if the defintion is local
2355      (ie. within the basic block) && has only one definition &&
2356      that definiion is either a return value from a
2357      function or does not contain any variables in
2358      far space */
2359   if (bitVectnBitsOn (OP_USES (op)) > 1)
2360     return NULL;
2361
2362   /* if it has only one defintion */
2363   if (bitVectnBitsOn (OP_DEFS (op)) > 1)
2364     return NULL;                /* has more than one definition */
2365
2366   /* get that definition */
2367   if (!(dic =
2368         hTabItemWithKey (iCodehTab,
2369                          bitVectFirstBit (OP_DEFS (op)))))
2370     return NULL;
2371
2372   /* if that only usage is a cast */
2373   if (dic->op == CAST) {
2374     /* to a bigger type */
2375     if (getSize(OP_SYM_TYPE(IC_RESULT(dic))) >
2376         getSize(OP_SYM_TYPE(IC_RIGHT(dic)))) {
2377       /* than we can not, since we cannot predict the usage of b & acc */
2378       return NULL;
2379     }
2380   }
2381
2382   /* found the definition now check if it is local */
2383   if (dic->seq < ebp->fSeq ||
2384       dic->seq > ebp->lSeq)
2385     return NULL;                /* non-local */
2386
2387   /* now check if it is the return from
2388      a function call */
2389   if (dic->op == CALL || dic->op == PCALL)
2390     {
2391       if (ic->op != SEND && ic->op != RETURN &&
2392           !POINTER_SET(ic) && !POINTER_GET(ic))
2393         {
2394           OP_SYMBOL (op)->ruonly = 1;
2395           return dic;
2396         }
2397     }
2398   else
2399     {
2400   /* otherwise check that the definition does
2401      not contain any symbols in far space */
2402   if (isOperandInFarSpace (IC_LEFT (dic)) ||
2403       isOperandInFarSpace (IC_RIGHT (dic)) ||
2404       IS_OP_RUONLY (IC_LEFT (ic)) ||
2405       IS_OP_RUONLY (IC_RIGHT (ic)))
2406     {
2407       return NULL;
2408     }
2409
2410   /* if pointer set then make sure the pointer
2411      is one byte */
2412   if (POINTER_SET (dic) &&
2413       !IS_DATA_PTR (aggrToPtr (operandType (IC_RESULT (dic)), FALSE)))
2414     return NULL;
2415
2416   if (POINTER_GET (dic) &&
2417       !IS_DATA_PTR (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)))
2418     return NULL;
2419     }
2420
2421   /* Make sure no overlapping liverange is already assigned to DPTR */
2422   if (OP_SYMBOL(op)->clashes)
2423     {
2424       symbol *sym;
2425       int i;
2426
2427       for (i = 0 ; i < OP_SYMBOL(op)->clashes->size ; i++ )
2428         {
2429           if (bitVectBitValue(OP_SYMBOL(op)->clashes,i))
2430             {
2431               sym = hTabItemWithKey(liveRanges,i);
2432               if (sym->ruonly)
2433                 return NULL ;
2434             }
2435         }
2436     }
2437
2438   sic = dic;
2439
2440   /* also make sure the intervenening instructions
2441      don't have any thing in far space */
2442   for (dic = dic->next; dic && dic != ic && sic != ic; dic = dic->next)
2443     {
2444
2445       /* if there is an intervening function call then no */
2446       if (dic->op == CALL || dic->op == PCALL)
2447         return NULL;
2448       /* if pointer set then make sure the pointer
2449          is one byte */
2450       if (POINTER_SET (dic) &&
2451           !IS_DATA_PTR (aggrToPtr (operandType (IC_RESULT (dic)), FALSE)))
2452         return NULL;
2453
2454       if (POINTER_GET (dic) &&
2455           !IS_DATA_PTR (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)))
2456         return NULL;
2457
2458       /* if address of & the result is remat the okay */
2459       if (dic->op == ADDRESS_OF &&
2460           OP_SYMBOL (IC_RESULT (dic))->remat)
2461         continue;
2462
2463       /* if operand has size of three or more & this
2464          operation is a '*','/' or '%' then 'b' may
2465          cause a problem */
2466       if ((dic->op == '%' || dic->op == '/' || dic->op == '*') &&
2467           getSize (operandType (op)) >= 3)
2468         return NULL;
2469
2470       /* if left or right or result is in far space */
2471       if (isOperandInFarSpace (IC_LEFT (dic)) ||
2472           isOperandInFarSpace (IC_RIGHT (dic)) ||
2473           isOperandInFarSpace (IC_RESULT (dic)) ||
2474           IS_OP_RUONLY (IC_LEFT (dic)) ||
2475           IS_OP_RUONLY (IC_RIGHT (dic)) ||
2476           IS_OP_RUONLY (IC_RESULT (dic)))
2477         {
2478           return NULL;
2479         }
2480       /* if left or right or result is on stack */
2481       if (isOperandOnStack(IC_LEFT(dic)) ||
2482           isOperandOnStack(IC_RIGHT(dic)) ||
2483           isOperandOnStack(IC_RESULT(dic))) {
2484         return NULL;
2485       }
2486     }
2487
2488   OP_SYMBOL (op)->ruonly = 1;
2489   return sic;
2490 }
2491
2492 /*-----------------------------------------------------------------*/
2493 /* isBitwiseOptimizable - requirements of JEAN LOUIS VERN          */
2494 /*-----------------------------------------------------------------*/
2495 static bool
2496 isBitwiseOptimizable (iCode * ic)
2497 {
2498   sym_link *ltype = getSpec (operandType (IC_LEFT (ic)));
2499   sym_link *rtype = getSpec (operandType (IC_RIGHT (ic)));
2500
2501   /* bitwise operations are considered optimizable
2502      under the following conditions (Jean-Louis VERN)
2503
2504      x & lit
2505      bit & bit
2506      bit & x
2507      bit ^ bit
2508      bit ^ x
2509      x   ^ lit
2510      x   | lit
2511      bit | bit
2512      bit | x
2513   */
2514   if (IS_LITERAL(rtype) ||
2515       (IS_BITVAR (ltype) && IN_BITSPACE (SPEC_OCLS (ltype))))
2516     return TRUE;
2517   else
2518     return FALSE;
2519 }
2520
2521 /*-----------------------------------------------------------------*/
2522 /* isCommutativeOp - tests whether this op cares what order its    */
2523 /*                   operands are in                               */
2524 /*-----------------------------------------------------------------*/
2525 bool isCommutativeOp(unsigned int op)
2526 {
2527   if (op == '+' || op == '*' || op == EQ_OP ||
2528       op == '^' || op == '|' || op == BITWISEAND)
2529     return TRUE;
2530   else
2531     return FALSE;
2532 }
2533
2534 /*-----------------------------------------------------------------*/
2535 /* operandUsesAcc - determines whether the code generated for this */
2536 /*                  operand will have to use the accumulator       */
2537 /*-----------------------------------------------------------------*/
2538 bool operandUsesAcc(operand *op)
2539 {
2540   if (!op)
2541     return FALSE;
2542
2543   if (IS_SYMOP(op)) {
2544     symbol *sym = OP_SYMBOL(op);
2545     memmap *symspace;
2546
2547     if (sym->accuse)
2548       return TRUE;  /* duh! */
2549
2550     if (IN_STACK(sym->etype) || sym->onStack ||
2551         (SPIL_LOC(op) && SPIL_LOC(op)->onStack))
2552       return TRUE;  /* acc is used to calc stack offset */
2553
2554     if (IS_ITEMP(op))
2555       {
2556         if (SPIL_LOC(op)) {
2557           sym = SPIL_LOC(op);  /* if spilled, look at spill location */
2558         } else {
2559           return FALSE;  /* more checks? */
2560         }
2561       }
2562
2563     symspace = SPEC_OCLS(sym->etype);
2564
2565     if (sym->iaccess && symspace->paged)
2566       return TRUE;  /* must fetch paged indirect sym via accumulator */
2567
2568     if (IN_BITSPACE(symspace))
2569       return TRUE;  /* fetching bit vars uses the accumulator */
2570
2571     if (IN_FARSPACE(symspace) || IN_CODESPACE(symspace))
2572       return TRUE;  /* fetched via accumulator and dptr */
2573   }
2574
2575   return FALSE;
2576 }
2577
2578 /*-----------------------------------------------------------------*/
2579 /* packRegsForAccUse - pack registers for acc use                  */
2580 /*-----------------------------------------------------------------*/
2581 static void
2582 packRegsForAccUse (iCode * ic)
2583 {
2584   iCode *uic;
2585
2586   /* if this is an aggregate, e.g. a one byte char array */
2587   if (IS_AGGREGATE(operandType(IC_RESULT(ic)))) {
2588     return;
2589   }
2590
2591   /* if we are calling a reentrant function that has stack parameters */
2592   if (ic->op == CALL &&
2593        IFFUNC_ISREENT(operandType(IC_LEFT(ic))) &&
2594        FUNC_HASSTACKPARM(operandType(IC_LEFT(ic))))
2595       return;
2596
2597   if (ic->op == PCALL &&
2598        IFFUNC_ISREENT(operandType(IC_LEFT(ic))->next) &&
2599        FUNC_HASSTACKPARM(operandType(IC_LEFT(ic))->next))
2600       return;
2601
2602   /* if + or - then it has to be one byte result */
2603   if ((ic->op == '+' || ic->op == '-')
2604       && getSize (operandType (IC_RESULT (ic))) > 1)
2605     return;
2606
2607   /* if shift operation make sure right side is not a literal */
2608   if (ic->op == RIGHT_OP &&
2609       (isOperandLiteral (IC_RIGHT (ic)) ||
2610        getSize (operandType (IC_RESULT (ic))) > 1))
2611     return;
2612
2613   if (ic->op == LEFT_OP &&
2614       (isOperandLiteral (IC_RIGHT (ic)) ||
2615        getSize (operandType (IC_RESULT (ic))) > 1))
2616     return;
2617
2618   if (IS_BITWISE_OP (ic) &&
2619       getSize (operandType (IC_RESULT (ic))) > 1)
2620     return;
2621
2622
2623   /* has only one definition */
2624   if (bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) > 1)
2625     return;
2626
2627   /* has only one use */
2628   if (bitVectnBitsOn (OP_USES (IC_RESULT (ic))) > 1)
2629     return;
2630
2631   /* and the usage immediately follows this iCode */
2632   if (!(uic = hTabItemWithKey (iCodehTab,
2633                                bitVectFirstBit (OP_USES (IC_RESULT (ic))))))
2634     return;
2635
2636   if (ic->next != uic)
2637     return;
2638
2639   /* if it is a conditional branch then we definitely can */
2640   if (uic->op == IFX)
2641     goto accuse;
2642
2643   if (uic->op == JUMPTABLE)
2644     return;
2645
2646   if (POINTER_SET (uic) &&
2647       getSize (aggrToPtr (operandType (IC_RESULT (uic)), FALSE)) > 1)
2648     return;
2649
2650   /* if the usage is not is an assignment
2651      or an arithmetic / bitwise / shift operation then not */
2652   if (uic->op != '=' &&
2653       !IS_ARITHMETIC_OP (uic) &&
2654       !IS_BITWISE_OP (uic) &&
2655       uic->op != LEFT_OP &&
2656       uic->op != RIGHT_OP)
2657     return;
2658
2659   /* if used in ^ operation then make sure right is not a
2660      literal (WIML: Why is this?) */
2661   if (uic->op == '^' && isOperandLiteral (IC_RIGHT (uic)))
2662     return;
2663
2664   /* if shift operation make sure right side is not a literal */
2665   /* WIML: Why is this? */
2666   if (uic->op == RIGHT_OP &&
2667       (isOperandLiteral (IC_RIGHT (uic)) ||
2668        getSize (operandType (IC_RESULT (uic))) > 1))
2669     return;
2670   if (uic->op == LEFT_OP &&
2671       (isOperandLiteral (IC_RIGHT (uic)) ||
2672        getSize (operandType (IC_RESULT (uic))) > 1))
2673     return;
2674
2675   /* make sure that the result of this icode is not on the
2676      stack, since acc is used to compute stack offset */
2677 #if 0
2678   if (IS_TRUE_SYMOP (IC_RESULT (uic)) &&
2679       OP_SYMBOL (IC_RESULT (uic))->onStack)
2680     return;
2681 #else
2682   if (isOperandOnStack(IC_RESULT(uic)))
2683     return;
2684 #endif
2685
2686   /* if the usage has only one operand then we can */
2687   if (IC_LEFT (uic) == NULL ||
2688       IC_RIGHT (uic) == NULL)
2689     goto accuse;
2690
2691   /* if the other operand uses the accumulator then we cannot */
2692   if ( (IC_LEFT(uic)->key == IC_RESULT(ic)->key &&
2693         operandUsesAcc(IC_RIGHT(uic))) ||
2694        (IC_RIGHT(uic)->key == IC_RESULT(ic)->key &&
2695         operandUsesAcc(IC_LEFT(uic))) )
2696     return;
2697
2698   /* make sure this is on the left side if not commutative */
2699   /* except for '-', which has been written to be able to
2700      handle reversed operands */
2701   if (!(isCommutativeOp(ic->op) || ic->op == '-') &&
2702        IC_LEFT (uic)->key != IC_RESULT (ic)->key)
2703     return;
2704
2705 #if 0
2706   // this is too dangerous and need further restrictions
2707   // see bug #447547
2708
2709   /* if one of them is a literal then we can */
2710   if ((IC_LEFT (uic) && IS_OP_LITERAL (IC_LEFT (uic))) ||
2711       (IC_RIGHT (uic) && IS_OP_LITERAL (IC_RIGHT (uic))))
2712     {
2713       OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
2714       return;
2715     }
2716 #endif
2717
2718 accuse:
2719   OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
2720
2721 }
2722
2723 /*-----------------------------------------------------------------*/
2724 /* packForPush - heuristics to reduce iCode for pushing            */
2725 /*-----------------------------------------------------------------*/
2726 static void
2727 packForPush (iCode * ic, eBBlock ** ebpp, int blockno)
2728 {
2729   iCode *dic, *lic;
2730   bitVect *dbv;
2731   struct eBBlock * ebp=ebpp[blockno];
2732
2733   if (ic->op != IPUSH || !IS_ITEMP (IC_LEFT (ic)))
2734     return;
2735
2736   /* must have only definition & one usage */
2737   if (bitVectnBitsOn (OP_DEFS (IC_LEFT (ic))) != 1 ||
2738       bitVectnBitsOn (OP_USES (IC_LEFT (ic))) != 1)
2739     return;
2740
2741   /* find the definition */
2742   if (!(dic = hTabItemWithKey (iCodehTab,
2743                                bitVectFirstBit (OP_DEFS (IC_LEFT (ic))))))
2744     return;
2745
2746   if (dic->op != '=' || POINTER_SET (dic))
2747     return;
2748
2749   if (dic->seq < ebp->fSeq) { // Evelyn did this
2750     int i;
2751     for (i=0; i<blockno; i++) {
2752       if (dic->seq >= ebpp[i]->fSeq && dic->seq <= ebpp[i]->lSeq) {
2753         ebp=ebpp[i];
2754         break;
2755       }
2756     }
2757     wassert (i!=blockno); // no way to recover from here
2758   }
2759
2760   if (IS_SYMOP(IC_RIGHT(dic))) {
2761     /* make sure the right side does not have any definitions
2762        inbetween */
2763     dbv = OP_DEFS(IC_RIGHT(dic));
2764     for (lic = ic; lic && lic != dic ; lic = lic->prev) {
2765       if (bitVectBitValue(dbv,lic->key))
2766         return ;
2767     }
2768     /* make sure they have the same type */
2769     if (IS_SPEC(operandType(IC_LEFT(ic))))
2770     {
2771       sym_link *itype=operandType(IC_LEFT(ic));
2772       sym_link *ditype=operandType(IC_RIGHT(dic));
2773
2774       if (SPEC_USIGN(itype)!=SPEC_USIGN(ditype) ||
2775           SPEC_LONG(itype)!=SPEC_LONG(ditype))
2776         return;
2777     }
2778     /* extend the live range of replaced operand if needed */
2779     if (OP_SYMBOL(IC_RIGHT(dic))->liveTo < ic->seq) {
2780       OP_SYMBOL(IC_RIGHT(dic))->liveTo = ic->seq;
2781     }
2782     bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2783   }
2784
2785   /* we now we know that it has one & only one def & use
2786      and the that the definition is an assignment */
2787   ReplaceOpWithCheaperOp(&IC_LEFT (ic), IC_RIGHT (dic));
2788   remiCodeFromeBBlock (ebp, dic);
2789   hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2790 }
2791
2792 /*-----------------------------------------------------------------*/
2793 /* packRegisters - does some transformations to reduce register    */
2794 /*                   pressure                                      */
2795 /*-----------------------------------------------------------------*/
2796 static void
2797 packRegisters (eBBlock ** ebpp, int blockno)
2798 {
2799   iCode *ic;
2800   int change = 0;
2801   eBBlock *ebp=ebpp[blockno];
2802
2803   while (1)
2804     {
2805       change = 0;
2806
2807       /* look for assignments of the form */
2808       /* iTempNN = TRueSym (someoperation) SomeOperand */
2809       /*       ....                       */
2810       /* TrueSym := iTempNN:1             */
2811       for (ic = ebp->sch; ic; ic = ic->next)
2812         {
2813           /* find assignment of the form TrueSym := iTempNN:1 */
2814           if (ic->op == '=' && !POINTER_SET (ic))
2815             change += packRegsForAssign (ic, ebp);
2816         }
2817
2818       if (!change)
2819         break;
2820     }
2821
2822   for (ic = ebp->sch; ic; ic = ic->next)
2823     {
2824       /* Fix for bug #979599:   */
2825       /* P0 &= ~1;              */
2826
2827       /* Look for two subsequent iCodes with */
2828       /*   iTemp := _c;         */
2829       /*   _c = iTemp & op;     */
2830       /* and replace them by    */
2831       /*   iTemp := _c;         */
2832       /*   _c = _c & op;        */
2833       if ((ic->op == BITWISEAND || ic->op == '|' || ic->op == '^') &&
2834           ic->prev &&
2835           ic->prev->op == '=' &&
2836           IS_ITEMP (IC_LEFT (ic)) &&
2837           IC_LEFT (ic) == IC_RESULT (ic->prev) &&
2838           isOperandEqual (IC_RESULT(ic), IC_RIGHT(ic->prev)))
2839         {
2840           iCode* ic_prev = ic->prev;
2841           symbol* prev_result_sym = OP_SYMBOL (IC_RESULT (ic_prev));
2842
2843           ReplaceOpWithCheaperOp (&IC_LEFT (ic), IC_RESULT (ic));
2844           if (IC_RESULT (ic_prev) != IC_RIGHT (ic))
2845             {
2846               bitVectUnSetBit (OP_USES (IC_RESULT (ic_prev)), ic->key);
2847               if (/*IS_ITEMP (IC_RESULT (ic_prev)) && */
2848                   prev_result_sym->liveTo == ic->seq)
2849                 {
2850                   prev_result_sym->liveTo = ic_prev->seq;
2851                 }
2852             }
2853           bitVectSetBit (OP_USES (IC_RESULT (ic)), ic->key);
2854
2855           bitVectSetBit (ic->rlive, IC_RESULT (ic)->key);
2856
2857           if (bitVectIsZero (OP_USES (IC_RESULT (ic_prev))))
2858             {
2859               bitVectUnSetBit (ic->rlive, IC_RESULT (ic)->key);
2860               bitVectUnSetBit (OP_DEFS (IC_RESULT (ic_prev)), ic_prev->key);
2861               remiCodeFromeBBlock (ebp, ic_prev);
2862               hTabDeleteItem (&iCodehTab, ic_prev->key, ic_prev, DELETE_ITEM, NULL);
2863             }
2864         }
2865
2866       /* if this is an itemp & result of an address of a true sym
2867          then mark this as rematerialisable   */
2868       if (ic->op == ADDRESS_OF &&
2869           IS_ITEMP (IC_RESULT (ic)) &&
2870           IS_TRUE_SYMOP (IC_LEFT (ic)) &&
2871           bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
2872           !OP_SYMBOL (IC_LEFT (ic))->onStack)
2873         {
2874           OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2875           OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2876           OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2877         }
2878
2879       /* if straight assignment then carry remat flag if
2880          this is the only definition */
2881       if (ic->op == '=' &&
2882           !POINTER_SET (ic) &&
2883           IS_SYMOP (IC_RIGHT (ic)) &&
2884           OP_SYMBOL (IC_RIGHT (ic))->remat &&
2885           !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode) &&
2886           bitVectnBitsOn (OP_SYMBOL (IC_RESULT (ic))->defs) <= 1)
2887         {
2888           OP_SYMBOL (IC_RESULT (ic))->remat =
2889             OP_SYMBOL (IC_RIGHT (ic))->remat;
2890           OP_SYMBOL (IC_RESULT (ic))->rematiCode =
2891             OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
2892         }
2893
2894       /* if cast to a generic pointer & the pointer being
2895          cast is remat, then we can remat this cast as well */
2896       if (ic->op == CAST &&
2897           IS_SYMOP(IC_RIGHT(ic)) &&
2898           OP_SYMBOL(IC_RIGHT(ic))->remat &&
2899           bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1)
2900         {
2901           sym_link *to_type = operandType(IC_LEFT(ic));
2902           sym_link *from_type = operandType(IC_RIGHT(ic));
2903           if (IS_GENPTR(to_type) && IS_PTR(from_type))
2904             {
2905               OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2906               OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2907               OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2908             }
2909         }
2910
2911       /* if this is a +/- operation with a rematerizable
2912          then mark this as rematerializable as well */
2913       if ((ic->op == '+' || ic->op == '-') &&
2914           (IS_SYMOP (IC_LEFT (ic)) &&
2915            IS_ITEMP (IC_RESULT (ic)) &&
2916            IS_OP_LITERAL (IC_RIGHT (ic))) &&
2917            OP_SYMBOL (IC_LEFT (ic))->remat &&
2918           (!IS_SYMOP (IC_RIGHT (ic)) || !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode)) &&
2919            bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1)
2920         {
2921           OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2922           OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2923           OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2924         }
2925
2926       /* mark the pointer usages */
2927       if (POINTER_SET (ic))
2928         OP_SYMBOL (IC_RESULT (ic))->uptr = 1;
2929
2930       if (POINTER_GET (ic) &&
2931           IS_SYMOP(IC_LEFT (ic)))
2932         OP_SYMBOL (IC_LEFT (ic))->uptr = 1;
2933
2934       if (!SKIP_IC2 (ic))
2935         {
2936           /* if we are using a symbol on the stack
2937              then we should say mcs51_ptrRegReq */
2938           if (options.useXstack && ic->parmPush
2939               && (ic->op == IPUSH || ic->op == IPOP))
2940             mcs51_ptrRegReq++;
2941           if (ic->op == IFX && IS_SYMOP (IC_COND (ic)))
2942             mcs51_ptrRegReq += ((OP_SYMBOL (IC_COND (ic))->onStack ||
2943                                  OP_SYMBOL (IC_COND (ic))->iaccess ||
2944                                  SPEC_OCLS(OP_SYMBOL (IC_COND (ic))->etype) == idata) ? 1 : 0);
2945           else if (ic->op == JUMPTABLE && IS_SYMOP (IC_JTCOND (ic)))
2946             mcs51_ptrRegReq += ((OP_SYMBOL (IC_JTCOND (ic))->onStack ||
2947                               OP_SYMBOL (IC_JTCOND (ic))->iaccess ||
2948                               SPEC_OCLS(OP_SYMBOL (IC_JTCOND (ic))->etype) == idata) ? 1 : 0);
2949           else
2950             {
2951               if (IS_SYMOP (IC_LEFT (ic)))
2952                 mcs51_ptrRegReq += ((OP_SYMBOL (IC_LEFT (ic))->onStack ||
2953                                 OP_SYMBOL (IC_LEFT (ic))->iaccess ||
2954                                 SPEC_OCLS(OP_SYMBOL (IC_LEFT (ic))->etype) == idata) ? 1 : 0);
2955               if (IS_SYMOP (IC_RIGHT (ic)))
2956                 mcs51_ptrRegReq += ((OP_SYMBOL (IC_RIGHT (ic))->onStack ||
2957                                OP_SYMBOL (IC_RIGHT (ic))->iaccess ||
2958                                SPEC_OCLS(OP_SYMBOL (IC_RIGHT (ic))->etype) == idata) ? 1 : 0);
2959               if (IS_SYMOP (IC_RESULT (ic)))
2960                 mcs51_ptrRegReq += ((OP_SYMBOL (IC_RESULT (ic))->onStack ||
2961                               OP_SYMBOL (IC_RESULT (ic))->iaccess ||
2962                               SPEC_OCLS(OP_SYMBOL (IC_RESULT (ic))->etype) == idata) ? 1 : 0);
2963               if (POINTER_GET (ic) && IS_SYMOP (IC_LEFT (ic))
2964                   && getSize (OP_SYMBOL (IC_LEFT (ic))->type) <= (unsigned int) PTRSIZE)
2965                 mcs51_ptrRegReq ++;
2966               if (POINTER_SET (ic) && IS_SYMOP (IC_RESULT (ic))
2967                   && getSize (OP_SYMBOL (IC_RESULT (ic))->type) <= (unsigned int) PTRSIZE)
2968                 mcs51_ptrRegReq ++;
2969             }
2970         }
2971
2972       /* if the condition of an if instruction
2973          is defined in the previous instruction and
2974          this is the only usage then
2975          mark the itemp as a conditional */
2976       if ((IS_CONDITIONAL (ic) ||
2977            (IS_BITWISE_OP(ic) && isBitwiseOptimizable (ic))) &&
2978           ic->next && ic->next->op == IFX &&
2979           bitVectnBitsOn (OP_USES(IC_RESULT(ic)))==1 &&
2980           isOperandEqual (IC_RESULT (ic), IC_COND (ic->next)) &&
2981           OP_SYMBOL (IC_RESULT (ic))->liveTo <= ic->next->seq)
2982         {
2983           OP_SYMBOL (IC_RESULT (ic))->regType = REG_CND;
2984           continue;
2985         }
2986
2987       /* if the condition of an if instruction
2988          is defined in the previous GET_POINTER instruction and
2989          this is the only usage then
2990          mark the itemp as accumulator use */
2991       if ((POINTER_GET (ic) && getSize (operandType (IC_RESULT (ic))) <=1) &&
2992           ic->next && ic->next->op == IFX &&
2993           bitVectnBitsOn (OP_USES(IC_RESULT(ic)))==1 &&
2994           isOperandEqual (IC_RESULT (ic), IC_COND (ic->next)) &&
2995           OP_SYMBOL (IC_RESULT (ic))->liveTo <= ic->next->seq)
2996         {
2997           OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
2998           continue;
2999         }
3000
3001       /* reduce for support function calls */
3002       if (ic->supportRtn || ic->op == '+' || ic->op == '-')
3003         packRegsForSupport (ic, ebp);
3004
3005       /* some cases the redundant moves can
3006          can be eliminated for return statements */
3007       if ((ic->op == RETURN || (ic->op == SEND && ic->argreg == 1)) &&
3008           !isOperandInFarSpace (IC_LEFT (ic)) &&
3009           options.model == MODEL_SMALL) {
3010         packRegsForOneuse (ic, IC_LEFT (ic), ebp);
3011       }
3012
3013       /* if pointer set & left has a size more than
3014          one and right is not in far space */
3015       if (POINTER_SET (ic) &&
3016           !isOperandInFarSpace (IC_RIGHT (ic)) &&
3017           !OP_SYMBOL (IC_RESULT (ic))->remat &&
3018           !IS_OP_RUONLY (IC_RIGHT (ic)) &&
3019           getSize (aggrToPtr (operandType (IC_RESULT (ic)), FALSE)) > 1)
3020         packRegsForOneuse (ic, IC_RESULT (ic), ebp);
3021
3022       /* if pointer get */
3023       if (POINTER_GET (ic) &&
3024           IS_SYMOP (IC_LEFT (ic)) &&
3025           !isOperandInFarSpace (IC_RESULT (ic)) &&
3026           !OP_SYMBOL (IC_LEFT (ic))->remat &&
3027           !IS_OP_RUONLY (IC_RESULT (ic)) &&
3028           getSize (aggrToPtr (operandType (IC_LEFT (ic)), FALSE)) > 1)
3029         packRegsForOneuse (ic, IC_LEFT (ic), ebp);
3030
3031
3032       /* if this is a cast for intergral promotion then
3033          check if it's the only use of the definition of the
3034          operand being casted/ if yes then replace
3035          the result of that arithmetic operation with
3036          this result and get rid of the cast */
3037       if (ic->op == CAST)
3038         {
3039           sym_link *fromType = operandType (IC_RIGHT (ic));
3040           sym_link *toType = operandType (IC_LEFT (ic));
3041
3042           if (IS_INTEGRAL (fromType) && IS_INTEGRAL (toType) &&
3043               getSize (fromType) != getSize (toType) &&
3044               SPEC_USIGN (fromType) == SPEC_USIGN (toType))
3045             {
3046
3047               iCode *dic = packRegsForOneuse (ic, IC_RIGHT (ic), ebp);
3048               if (dic)
3049                 {
3050                   if (IS_ARITHMETIC_OP (dic))
3051                     {
3052                       bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
3053                       ReplaceOpWithCheaperOp(&IC_RESULT (dic), IC_RESULT (ic));
3054                       remiCodeFromeBBlock (ebp, ic);
3055                       bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
3056                       hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
3057                       OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
3058                       ic = ic->prev;
3059                     }
3060                   else
3061                     OP_SYMBOL (IC_RIGHT (ic))->ruonly = 0;
3062                 }
3063             }
3064           else
3065             {
3066
3067               /* if the type from and type to are the same
3068                  then if this is the only use then packit */
3069               if (compareType (operandType (IC_RIGHT (ic)),
3070                              operandType (IC_LEFT (ic))) == 1)
3071                 {
3072                   iCode *dic = packRegsForOneuse (ic, IC_RIGHT (ic), ebp);
3073                   if (dic)
3074                     {
3075                       bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
3076                       ReplaceOpWithCheaperOp(&IC_RESULT (dic), IC_RESULT (ic));
3077                       remiCodeFromeBBlock (ebp, ic);
3078                       bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
3079                       hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
3080                       OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
3081                       ic = ic->prev;
3082                     }
3083                 }
3084             }
3085         }
3086
3087       /* pack for PUSH
3088          iTempNN := (some variable in farspace) V1
3089          push iTempNN ;
3090          -------------
3091          push V1
3092        */
3093       if (ic->op == IPUSH)
3094         {
3095           packForPush (ic, ebpp, blockno);
3096         }
3097
3098
3099       /* pack registers for accumulator use, when the
3100          result of an arithmetic or bit wise operation
3101          has only one use, that use is immediately following
3102          the defintion and the using iCode has only one
3103          operand or has two operands but one is literal &
3104          the result of that operation is not on stack then
3105          we can leave the result of this operation in acc:b
3106          combination */
3107       if ((IS_ARITHMETIC_OP (ic)
3108            || IS_CONDITIONAL(ic)
3109            || IS_BITWISE_OP (ic)
3110            || ic->op == LEFT_OP || ic->op == RIGHT_OP || ic->op == CALL
3111            || (ic->op == ADDRESS_OF && isOperandOnStack (IC_LEFT (ic)))
3112           ) &&
3113           IS_ITEMP (IC_RESULT (ic)) &&
3114           getSize (operandType (IC_RESULT (ic))) <= 2)
3115
3116         packRegsForAccUse (ic);
3117     }
3118 }
3119
3120 /*-----------------------------------------------------------------*/
3121 /* assignRegisters - assigns registers to each live range as need  */
3122 /*-----------------------------------------------------------------*/
3123 void
3124 mcs51_assignRegisters (eBBlock ** ebbs, int count)
3125 {
3126   iCode *ic;
3127   int i;
3128
3129   setToNull ((void *) &_G.funcrUsed);
3130   setToNull ((void *) &_G.regAssigned);
3131   setToNull ((void *) &_G.totRegAssigned);
3132   mcs51_ptrRegReq = _G.stackExtend = _G.dataExtend = 0;
3133   mcs51_nRegs = 8;
3134
3135   /* change assignments this will remove some
3136      live ranges reducing some register pressure */
3137
3138   for (i = 0; i < count; i++)
3139     packRegisters (ebbs, i);
3140
3141   /* liveranges probably changed by register packing
3142      so we compute them again */
3143   recomputeLiveRanges (ebbs, count);
3144
3145   if (options.dump_pack)
3146     dumpEbbsToFileExt (DUMP_PACK, ebbs, count);
3147
3148   /* first determine for each live range the number of
3149      registers & the type of registers required for each */
3150   regTypeNum (*ebbs);
3151
3152   /* and serially allocate registers */
3153   serialRegAssign (ebbs, count);
3154
3155   freeAllRegs ();
3156   //setToNull ((void *) &_G.regAssigned);
3157   //setToNull ((void *) &_G.totRegAssigned);
3158   fillGaps();
3159
3160   /* if stack was extended then tell the user */
3161   if (_G.stackExtend)
3162     {
3163 /*      werror(W_TOOMANY_SPILS,"stack", */
3164 /*             _G.stackExtend,currFunc->name,""); */
3165       _G.stackExtend = 0;
3166     }
3167
3168   if (_G.dataExtend)
3169     {
3170 /*      werror(W_TOOMANY_SPILS,"data space", */
3171 /*             _G.dataExtend,currFunc->name,""); */
3172       _G.dataExtend = 0;
3173     }
3174
3175   /* after that create the register mask
3176      for each of the instruction */
3177   createRegMask (ebbs, count);
3178
3179   /* redo that offsets for stacked automatic variables */
3180   if (currFunc) {
3181     redoStackOffsets ();
3182   }
3183
3184   /* make sure r0 & r1 are flagged as used if they might be used */
3185   /* as pointers */
3186   if (currFunc && mcs51_ptrRegReq)
3187     {
3188       currFunc->regsUsed = bitVectSetBit (currFunc->regsUsed, R0_IDX);
3189       currFunc->regsUsed = bitVectSetBit (currFunc->regsUsed, R1_IDX);
3190     }
3191
3192   if (options.dump_rassgn)
3193     {
3194       dumpEbbsToFileExt (DUMP_RASSGN, ebbs, count);
3195       dumpLiveRanges (DUMP_LRANGE, liveRanges);
3196     }
3197
3198   /* do the overlaysegment stuff SDCCmem.c */
3199   doOverlays (ebbs, count);
3200
3201   /* now get back the chain */
3202   ic = iCodeLabelOptimize (iCodeFromeBBlock (ebbs, count));
3203
3204   gen51Code (ic);
3205
3206   /* free up any _G.stackSpil locations allocated */
3207   applyToSet (_G.stackSpil, deallocStackSpil);
3208   _G.slocNum = 0;
3209   setToNull ((void *) &_G.stackSpil);
3210   setToNull ((void *) &_G.spiltSet);
3211   /* mark all registers as free */
3212   freeAllRegs ();
3213
3214   return;
3215 }