git.gag.com Git - fw/sdcc/blob - src/z80/ralloc.c

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