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