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