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