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

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