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

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