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           !POINTER_SET(ic) && !POINTER_GET(ic))
2100         {
2101           OP_SYMBOL (op)->ruonly = 1;
2102           return dic;
2103         }
2104       dic = dic->next;
2105     }
2106
2107
2108   /* otherwise check that the definition does
2109      not contain any symbols in far space */
2110   if (isOperandInFarSpace (IC_LEFT (dic)) ||
2111       isOperandInFarSpace (IC_RIGHT (dic)) ||
2112       IS_OP_RUONLY (IC_LEFT (ic)) ||
2113       IS_OP_RUONLY (IC_RIGHT (ic)))
2114     {
2115       return NULL;
2116     }
2117
2118   /* if pointer set then make sure the pointer
2119      is one byte */
2120   if (POINTER_SET (dic) &&
2121       !IS_DATA_PTR (aggrToPtr (operandType (IC_RESULT (dic)), FALSE)))
2122     return NULL;
2123
2124   if (POINTER_GET (dic) &&
2125       !IS_DATA_PTR (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)))
2126     return NULL;
2127
2128   sic = dic;
2129
2130   /* also make sure the intervenening instructions
2131      don't have any thing in far space */
2132   for (dic = dic->next; dic && dic != ic && sic != ic; dic = dic->next)
2133     {
2134
2135       /* if there is an intervening function call then no */
2136       if (dic->op == CALL || dic->op == PCALL)
2137         return NULL;
2138       /* if pointer set then make sure the pointer
2139          is one byte */
2140       if (POINTER_SET (dic) &&
2141           !IS_DATA_PTR (aggrToPtr (operandType (IC_RESULT (dic)), FALSE)))
2142         return NULL;
2143
2144       if (POINTER_GET (dic) &&
2145           !IS_DATA_PTR (aggrToPtr (operandType (IC_LEFT (dic)), FALSE)))
2146         return NULL;
2147
2148       /* if address of & the result is remat the okay */
2149       if (dic->op == ADDRESS_OF &&
2150           OP_SYMBOL (IC_RESULT (dic))->remat)
2151         continue;
2152
2153       /* if operand has size of three or more & this
2154          operation is a '*','/' or '%' then 'b' may
2155          cause a problem */
2156       if ((dic->op == '%' || dic->op == '/' || dic->op == '*') &&
2157           getSize (operandType (op)) >= 3)
2158         return NULL;
2159
2160       /* if left or right or result is in far space */
2161       if (isOperandInFarSpace (IC_LEFT (dic)) ||
2162           isOperandInFarSpace (IC_RIGHT (dic)) ||
2163           isOperandInFarSpace (IC_RESULT (dic)) ||
2164           IS_OP_RUONLY (IC_LEFT (dic)) ||
2165           IS_OP_RUONLY (IC_RIGHT (dic)) ||
2166           IS_OP_RUONLY (IC_RESULT (dic)))
2167         {
2168           return NULL;
2169         }
2170       /* if left or right or result is on stack */
2171       if (isOperandOnStack(IC_LEFT(dic)) ||
2172           isOperandOnStack(IC_RIGHT(dic)) ||
2173           isOperandOnStack(IC_RESULT(dic))) {
2174         return NULL;
2175       }
2176     }
2177
2178   OP_SYMBOL (op)->ruonly = 1;
2179   return sic;
2180
2181 }
2182
2183 /*-----------------------------------------------------------------*/
2184 /* isBitwiseOptimizable - requirements of JEAN LOUIS VERN          */
2185 /*-----------------------------------------------------------------*/
2186 static bool
2187 isBitwiseOptimizable (iCode * ic)
2188 {
2189   sym_link *ltype = getSpec (operandType (IC_LEFT (ic)));
2190   sym_link *rtype = getSpec (operandType (IC_RIGHT (ic)));
2191
2192   /* bitwise operations are considered optimizable
2193      under the following conditions (Jean-Louis VERN)
2194
2195      x & lit
2196      bit & bit
2197      bit & x
2198      bit ^ bit
2199      bit ^ x
2200      x   ^ lit
2201      x   | lit
2202      bit | bit
2203      bit | x
2204   */
2205   if (IS_LITERAL(rtype) ||
2206       (IS_BITVAR (ltype) && IN_BITSPACE (SPEC_OCLS (ltype))))
2207     return TRUE;
2208   else
2209     return FALSE;
2210 }
2211
2212 /*-----------------------------------------------------------------*/
2213 /* packRegsForAccUse - pack registers for acc use                  */
2214 /*-----------------------------------------------------------------*/
2215 static void
2216 packRegsForAccUse (iCode * ic)
2217 {
2218   iCode *uic;
2219
2220   /* if this is an aggregate, e.g. a one byte char array */
2221   if (IS_AGGREGATE(operandType(IC_RESULT(ic)))) {
2222     return;
2223   }
2224
2225   /* if + or - then it has to be one byte result */
2226   if ((ic->op == '+' || ic->op == '-')
2227       && getSize (operandType (IC_RESULT (ic))) > 1)
2228     return;
2229
2230   /* if shift operation make sure right side is not a literal */
2231   if (ic->op == RIGHT_OP &&
2232       (isOperandLiteral (IC_RIGHT (ic)) ||
2233        getSize (operandType (IC_RESULT (ic))) > 1))
2234     return;
2235
2236   if (ic->op == LEFT_OP &&
2237       (isOperandLiteral (IC_RIGHT (ic)) ||
2238        getSize (operandType (IC_RESULT (ic))) > 1))
2239     return;
2240
2241   if (IS_BITWISE_OP (ic) &&
2242       getSize (operandType (IC_RESULT (ic))) > 1)
2243     return;
2244
2245
2246   /* has only one definition */
2247   if (bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) > 1)
2248     return;
2249
2250   /* has only one use */
2251   if (bitVectnBitsOn (OP_USES (IC_RESULT (ic))) > 1)
2252     return;
2253
2254   /* and the usage immediately follows this iCode */
2255   if (!(uic = hTabItemWithKey (iCodehTab,
2256                                bitVectFirstBit (OP_USES (IC_RESULT (ic))))))
2257     return;
2258
2259   if (ic->next != uic)
2260     return;
2261
2262   /* if it is a conditional branch then we definitely can */
2263   if (uic->op == IFX)
2264     goto accuse;
2265
2266   if (uic->op == JUMPTABLE)
2267     return;
2268
2269   /* if the usage is not is an assignment
2270      or an arithmetic / bitwise / shift operation then not */
2271   if (POINTER_SET (uic) &&
2272       getSize (aggrToPtr (operandType (IC_RESULT (uic)), FALSE)) > 1)
2273     return;
2274
2275   if (uic->op != '=' &&
2276       !IS_ARITHMETIC_OP (uic) &&
2277       !IS_BITWISE_OP (uic) &&
2278       uic->op != LEFT_OP &&
2279       uic->op != RIGHT_OP)
2280     return;
2281
2282   /* if used in ^ operation then make sure right is not a
2283      literl */
2284   if (uic->op == '^' && isOperandLiteral (IC_RIGHT (uic)))
2285     return;
2286
2287   /* if shift operation make sure right side is not a literal */
2288   if (uic->op == RIGHT_OP &&
2289       (isOperandLiteral (IC_RIGHT (uic)) ||
2290        getSize (operandType (IC_RESULT (uic))) > 1))
2291     return;
2292
2293   if (uic->op == LEFT_OP &&
2294       (isOperandLiteral (IC_RIGHT (uic)) ||
2295        getSize (operandType (IC_RESULT (uic))) > 1))
2296     return;
2297
2298   /* make sure that the result of this icode is not on the
2299      stack, since acc is used to compute stack offset */
2300 #if 0
2301   if (IS_TRUE_SYMOP (IC_RESULT (uic)) &&
2302       OP_SYMBOL (IC_RESULT (uic))->onStack)
2303     return;
2304 #else
2305   if (isOperandOnStack(IC_RESULT(uic)))
2306     return;
2307 #endif
2308
2309   /* if either one of them in far space then we cannot */
2310   if ((IS_TRUE_SYMOP (IC_LEFT (uic)) &&
2311        isOperandInFarSpace (IC_LEFT (uic))) ||
2312       (IS_TRUE_SYMOP (IC_RIGHT (uic)) &&
2313        isOperandInFarSpace (IC_RIGHT (uic))))
2314     return;
2315
2316   /* if the usage has only one operand then we can */
2317   if (IC_LEFT (uic) == NULL ||
2318       IC_RIGHT (uic) == NULL)
2319     goto accuse;
2320
2321   /* make sure this is on the left side if not
2322      a '+' since '+' is commutative */
2323   if (ic->op != '+' &&
2324       IC_LEFT (uic)->key != IC_RESULT (ic)->key)
2325     return;
2326
2327 #if 0
2328   // this is too dangerous and need further restrictions
2329   // see bug #447547
2330
2331   /* if one of them is a literal then we can */
2332   if ((IC_LEFT (uic) && IS_OP_LITERAL (IC_LEFT (uic))) ||
2333       (IC_RIGHT (uic) && IS_OP_LITERAL (IC_RIGHT (uic))))
2334     {
2335       OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
2336       return;
2337     }
2338 #endif
2339
2340   /* if the other one is not on stack then we can */
2341   if (IC_LEFT (uic)->key == IC_RESULT (ic)->key &&
2342       (IS_ITEMP (IC_RIGHT (uic)) ||
2343        (IS_TRUE_SYMOP (IC_RIGHT (uic)) &&
2344         !OP_SYMBOL (IC_RIGHT (uic))->onStack)))
2345     goto accuse;
2346
2347   if (IC_RIGHT (uic)->key == IC_RESULT (ic)->key &&
2348       (IS_ITEMP (IC_LEFT (uic)) ||
2349        (IS_TRUE_SYMOP (IC_LEFT (uic)) &&
2350         !OP_SYMBOL (IC_LEFT (uic))->onStack)))
2351     goto accuse;
2352
2353   return;
2354
2355 accuse:
2356   OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
2357
2358
2359 }
2360
2361 /*-----------------------------------------------------------------*/
2362 /* packForPush - hueristics to reduce iCode for pushing            */
2363 /*-----------------------------------------------------------------*/
2364 static void
2365 packForPush (iCode * ic, eBBlock * ebp)
2366 {
2367   iCode *dic, *lic;
2368   bitVect *dbv;
2369
2370   if (ic->op != IPUSH || !IS_ITEMP (IC_LEFT (ic)))
2371     return;
2372
2373   /* must have only definition & one usage */
2374   if (bitVectnBitsOn (OP_DEFS (IC_LEFT (ic))) != 1 ||
2375       bitVectnBitsOn (OP_USES (IC_LEFT (ic))) != 1)
2376     return;
2377
2378   /* find the definition */
2379   if (!(dic = hTabItemWithKey (iCodehTab,
2380                                bitVectFirstBit (OP_DEFS (IC_LEFT (ic))))))
2381     return;
2382
2383   if (dic->op != '=' || POINTER_SET (dic))
2384     return;
2385
2386   /* make sure the right side does not have any definitions
2387      inbetween */
2388   dbv = OP_DEFS(IC_RIGHT(dic));
2389   for (lic = ic; lic && lic != dic ; lic = lic->prev) {
2390     if (bitVectBitValue(dbv,lic->key))
2391       return ;
2392   }
2393   /* make sure they have the same type */
2394   {
2395     sym_link *itype=operandType(IC_LEFT(ic));
2396     sym_link *ditype=operandType(IC_RIGHT(dic));
2397
2398     if (SPEC_USIGN(itype)!=SPEC_USIGN(ditype) ||
2399         SPEC_LONG(itype)!=SPEC_LONG(ditype))
2400       return;
2401   }
2402   /* extend the live range of replaced operand if needed */
2403   if (OP_SYMBOL(IC_RIGHT(dic))->liveTo < ic->seq) {
2404           OP_SYMBOL(IC_RIGHT(dic))->liveTo = ic->seq;
2405   }
2406   /* we now we know that it has one & only one def & use
2407      and the that the definition is an assignment */
2408   IC_LEFT (ic) = IC_RIGHT (dic);
2409
2410   remiCodeFromeBBlock (ebp, dic);
2411   bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2412   hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2413 }
2414
2415 /*-----------------------------------------------------------------*/
2416 /* packRegisters - does some transformations to reduce register    */
2417 /*                   pressure                                      */
2418 /*-----------------------------------------------------------------*/
2419 static void
2420 packRegisters (eBBlock * ebp)
2421 {
2422   iCode *ic;
2423   int change = 0;
2424
2425   while (1)
2426     {
2427
2428       change = 0;
2429
2430       /* look for assignments of the form */
2431       /* iTempNN = TRueSym (someoperation) SomeOperand */
2432       /*       ....                       */
2433       /* TrueSym := iTempNN:1             */
2434       for (ic = ebp->sch; ic; ic = ic->next)
2435         {
2436           /* find assignment of the form TrueSym := iTempNN:1 */
2437           if (ic->op == '=' && !POINTER_SET (ic))
2438             change += packRegsForAssign (ic, ebp);
2439         }
2440
2441       if (!change)
2442         break;
2443     }
2444
2445   for (ic = ebp->sch; ic; ic = ic->next)
2446     {
2447       /* if this is an itemp & result of an address of a true sym
2448          then mark this as rematerialisable   */
2449       if (ic->op == ADDRESS_OF &&
2450           IS_ITEMP (IC_RESULT (ic)) &&
2451           IS_TRUE_SYMOP (IC_LEFT (ic)) &&
2452           bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
2453           !OP_SYMBOL (IC_LEFT (ic))->onStack)
2454         {
2455
2456           OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2457           OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2458           OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2459
2460         }
2461
2462       /* if straight assignment then carry remat flag if
2463          this is the only definition */
2464       if (ic->op == '=' &&
2465           !POINTER_SET (ic) &&
2466           IS_SYMOP (IC_RIGHT (ic)) &&
2467           OP_SYMBOL (IC_RIGHT (ic))->remat &&
2468           !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode) &&
2469           bitVectnBitsOn (OP_SYMBOL (IC_RESULT (ic))->defs) <= 1)
2470         {
2471
2472           OP_SYMBOL (IC_RESULT (ic))->remat =
2473             OP_SYMBOL (IC_RIGHT (ic))->remat;
2474           OP_SYMBOL (IC_RESULT (ic))->rematiCode =
2475             OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
2476         }
2477
2478       /* if cast to a generic pointer & the pointer being
2479          cast is remat, then we can remat this cast as well */
2480       if (ic->op == CAST &&
2481           IS_SYMOP(IC_RIGHT(ic)) &&
2482           OP_SYMBOL(IC_RIGHT(ic))->remat ) {
2483               sym_link *to_type = operandType(IC_LEFT(ic));
2484               sym_link *from_type = operandType(IC_RIGHT(ic));
2485               if (IS_GENPTR(to_type) && IS_PTR(from_type)) {
2486                       OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2487                       OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2488                       OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2489               }
2490       }
2491
2492       /* if this is a +/- operation with a rematerizable
2493          then mark this as rematerializable as well */
2494       if ((ic->op == '+' || ic->op == '-') &&
2495           (IS_SYMOP (IC_LEFT (ic)) &&
2496            IS_ITEMP (IC_RESULT (ic)) &&
2497            IS_OP_LITERAL (IC_RIGHT (ic))) &&
2498            OP_SYMBOL (IC_LEFT (ic))->remat &&
2499           (!IS_SYMOP (IC_RIGHT (ic)) || !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode)) &&
2500            bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1)
2501         {
2502           OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2503           OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2504           OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2505         }
2506
2507       /* mark the pointer usages */
2508       if (POINTER_SET (ic))
2509         OP_SYMBOL (IC_RESULT (ic))->uptr = 1;
2510
2511       if (POINTER_GET (ic))
2512         OP_SYMBOL (IC_LEFT (ic))->uptr = 1;
2513
2514       if (!SKIP_IC2 (ic))
2515         {
2516           /* if we are using a symbol on the stack
2517              then we should say mcs51_ptrRegReq */
2518           if (ic->op == IFX && IS_SYMOP (IC_COND (ic)))
2519             mcs51_ptrRegReq += ((OP_SYMBOL (IC_COND (ic))->onStack ||
2520                                  OP_SYMBOL (IC_COND (ic))->iaccess) ? 1 : 0);
2521           else if (ic->op == JUMPTABLE && IS_SYMOP (IC_JTCOND (ic)))
2522             mcs51_ptrRegReq += ((OP_SYMBOL (IC_JTCOND (ic))->onStack ||
2523                               OP_SYMBOL (IC_JTCOND (ic))->iaccess) ? 1 : 0);
2524           else
2525             {
2526               if (IS_SYMOP (IC_LEFT (ic)))
2527                 mcs51_ptrRegReq += ((OP_SYMBOL (IC_LEFT (ic))->onStack ||
2528                                 OP_SYMBOL (IC_LEFT (ic))->iaccess) ? 1 : 0);
2529               if (IS_SYMOP (IC_RIGHT (ic)))
2530                 mcs51_ptrRegReq += ((OP_SYMBOL (IC_RIGHT (ic))->onStack ||
2531                                OP_SYMBOL (IC_RIGHT (ic))->iaccess) ? 1 : 0);
2532               if (IS_SYMOP (IC_RESULT (ic)))
2533                 mcs51_ptrRegReq += ((OP_SYMBOL (IC_RESULT (ic))->onStack ||
2534                               OP_SYMBOL (IC_RESULT (ic))->iaccess) ? 1 : 0);
2535             }
2536         }
2537
2538       /* if the condition of an if instruction
2539          is defined in the previous instruction and
2540          this is the only usage then
2541          mark the itemp as a conditional */
2542       if ((IS_CONDITIONAL (ic) ||
2543            (IS_BITWISE_OP(ic) && isBitwiseOptimizable (ic))) &&
2544           ic->next && ic->next->op == IFX &&
2545           bitVectnBitsOn (OP_USES(IC_RESULT(ic)))==1 &&
2546           isOperandEqual (IC_RESULT (ic), IC_COND (ic->next)) &&
2547           OP_SYMBOL (IC_RESULT (ic))->liveTo <= ic->next->seq)
2548         {
2549           OP_SYMBOL (IC_RESULT (ic))->regType = REG_CND;
2550           continue;
2551         }
2552
2553       /* reduce for support function calls */
2554       if (ic->supportRtn || ic->op == '+' || ic->op == '-')
2555         packRegsForSupport (ic, ebp);
2556
2557       /* some cases the redundant moves can
2558          can be eliminated for return statements */
2559       if ((ic->op == RETURN || ic->op == SEND) &&
2560           !isOperandInFarSpace (IC_LEFT (ic)) &&
2561           options.model == MODEL_SMALL) {
2562         if (0 && options.stackAuto) {
2563           /* we should check here if acc will be clobbered for stack
2564              offset calculations */
2565         } else {
2566           packRegsForOneuse (ic, IC_LEFT (ic), ebp);
2567         }
2568       }
2569
2570       /* if pointer set & left has a size more than
2571          one and right is not in far space */
2572       if (POINTER_SET (ic) &&
2573           !isOperandInFarSpace (IC_RIGHT (ic)) &&
2574           !OP_SYMBOL (IC_RESULT (ic))->remat &&
2575           !IS_OP_RUONLY (IC_RIGHT (ic)) &&
2576           getSize (aggrToPtr (operandType (IC_RESULT (ic)), FALSE)) > 1)
2577
2578         packRegsForOneuse (ic, IC_RESULT (ic), ebp);
2579
2580       /* if pointer get */
2581       if (POINTER_GET (ic) &&
2582           !isOperandInFarSpace (IC_RESULT (ic)) &&
2583           !OP_SYMBOL (IC_LEFT (ic))->remat &&
2584           !IS_OP_RUONLY (IC_RESULT (ic)) &&
2585           getSize (aggrToPtr (operandType (IC_LEFT (ic)), FALSE)) > 1)
2586
2587         packRegsForOneuse (ic, IC_LEFT (ic), ebp);
2588
2589
2590       /* if this is cast for intergral promotion then
2591          check if only use of  the definition of the
2592          operand being casted/ if yes then replace
2593          the result of that arithmetic operation with
2594          this result and get rid of the cast */
2595       if (ic->op == CAST)
2596         {
2597           sym_link *fromType = operandType (IC_RIGHT (ic));
2598           sym_link *toType = operandType (IC_LEFT (ic));
2599
2600           if (IS_INTEGRAL (fromType) && IS_INTEGRAL (toType) &&
2601               getSize (fromType) != getSize (toType) &&
2602               SPEC_USIGN (fromType) == SPEC_USIGN (toType))
2603             {
2604
2605               iCode *dic = packRegsForOneuse (ic, IC_RIGHT (ic), ebp);
2606               if (dic)
2607                 {
2608                   if (IS_ARITHMETIC_OP (dic))
2609                     {
2610                       bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2611                       IC_RESULT (dic) = IC_RESULT (ic);
2612                       remiCodeFromeBBlock (ebp, ic);
2613                       bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
2614                       hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
2615                       OP_DEFS (IC_RESULT (dic)) = bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
2616                       ic = ic->prev;
2617                     }
2618                   else
2619                     OP_SYMBOL (IC_RIGHT (ic))->ruonly = 0;
2620                 }
2621             }
2622           else
2623             {
2624
2625               /* if the type from and type to are the same
2626                  then if this is the only use then packit */
2627               if (compareType (operandType (IC_RIGHT (ic)),
2628                              operandType (IC_LEFT (ic))) == 1)
2629                 {
2630                   iCode *dic = packRegsForOneuse (ic, IC_RIGHT (ic), ebp);
2631                   if (dic)
2632                     {
2633                       bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2634                       IC_RESULT (dic) = IC_RESULT (ic);
2635                       remiCodeFromeBBlock (ebp, ic);
2636                       bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
2637                       hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
2638                       OP_DEFS (IC_RESULT (dic)) = bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
2639                       ic = ic->prev;
2640                     }
2641                 }
2642             }
2643         }
2644
2645       /* pack for PUSH
2646          iTempNN := (some variable in farspace) V1
2647          push iTempNN ;
2648          -------------
2649          push V1
2650        */
2651       if (ic->op == IPUSH)
2652         {
2653           packForPush (ic, ebp);
2654         }
2655
2656
2657       /* pack registers for accumulator use, when the
2658          result of an arithmetic or bit wise operation
2659          has only one use, that use is immediately following
2660          the defintion and the using iCode has only one
2661          operand or has two operands but one is literal &
2662          the result of that operation is not on stack then
2663          we can leave the result of this operation in acc:b
2664          combination */
2665       if ((IS_ARITHMETIC_OP (ic)
2666            || IS_CONDITIONAL(ic)
2667            || IS_BITWISE_OP (ic)
2668            || ic->op == LEFT_OP || ic->op == RIGHT_OP || ic->op == CALL
2669            || (ic->op == ADDRESS_OF && isOperandOnStack (IC_LEFT (ic)))
2670           ) &&
2671           IS_ITEMP (IC_RESULT (ic)) &&
2672           getSize (operandType (IC_RESULT (ic))) <= 2)
2673
2674         packRegsForAccUse (ic);
2675     }
2676 }
2677
2678 /*-----------------------------------------------------------------*/
2679 /* assignRegisters - assigns registers to each live range as need  */
2680 /*-----------------------------------------------------------------*/
2681 void
2682 mcs51_assignRegisters (eBBlock ** ebbs, int count)
2683 {
2684   iCode *ic;
2685   int i;
2686
2687   setToNull ((void *) &_G.funcrUsed);
2688   setToNull ((void *) &_G.totRegAssigned);
2689   mcs51_ptrRegReq = _G.stackExtend = _G.dataExtend = 0;
2690   mcs51_nRegs = 8;
2691
2692   /* change assignments this will remove some
2693      live ranges reducing some register pressure */
2694   for (i = 0; i < count; i++)
2695     packRegisters (ebbs[i]);
2696
2697   if (options.dump_pack)
2698     dumpEbbsToFileExt (DUMP_PACK, ebbs, count);
2699
2700   /* first determine for each live range the number of
2701      registers & the type of registers required for each */
2702   regTypeNum (*ebbs);
2703
2704   /* and serially allocate registers */
2705   serialRegAssign (ebbs, count);
2706
2707   freeAllRegs ();
2708   fillGaps();
2709
2710   /* if stack was extended then tell the user */
2711   if (_G.stackExtend)
2712     {
2713 /*      werror(W_TOOMANY_SPILS,"stack", */
2714 /*             _G.stackExtend,currFunc->name,""); */
2715       _G.stackExtend = 0;
2716     }
2717
2718   if (_G.dataExtend)
2719     {
2720 /*      werror(W_TOOMANY_SPILS,"data space", */
2721 /*             _G.dataExtend,currFunc->name,""); */
2722       _G.dataExtend = 0;
2723     }
2724
2725   /* after that create the register mask
2726      for each of the instruction */
2727   createRegMask (ebbs, count);
2728
2729   /* redo that offsets for stacked automatic variables */
2730   redoStackOffsets ();
2731
2732   if (options.dump_rassgn)
2733     {
2734       dumpEbbsToFileExt (DUMP_RASSGN, ebbs, count);
2735       dumpLiveRanges (DUMP_LRANGE, liveRanges);
2736     }
2737
2738   /* do the overlaysegment stuff SDCCmem.c */
2739   doOverlays (ebbs, count);
2740
2741   /* now get back the chain */
2742   ic = iCodeLabelOptimize (iCodeFromeBBlock (ebbs, count));
2743
2744   gen51Code (ic);
2745
2746   /* free up any _G.stackSpil locations allocated */
2747   applyToSet (_G.stackSpil, deallocStackSpil);
2748   _G.slocNum = 0;
2749   setToNull ((void **) &_G.stackSpil);
2750   setToNull ((void **) &_G.spiltSet);
2751   /* mark all registers as free */
2752   freeAllRegs ();
2753
2754   return;
2755 }