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