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