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