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

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