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