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

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