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

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