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

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