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