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

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