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