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

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