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