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 the result is on stack or iaccess then it must be
2118      the same atleast one of the operands */
2119   if (OP_SYMBOL (IC_RESULT (ic))->onStack ||
2120       OP_SYMBOL (IC_RESULT (ic))->iaccess)
2121     {
2122
2123       /* the operation has only one symbol
2124          operator then we can pack */
2125       if ((IC_LEFT (dic) && !IS_SYMOP (IC_LEFT (dic))) ||
2126           (IC_RIGHT (dic) && !IS_SYMOP (IC_RIGHT (dic))))
2127         goto pack;
2128
2129       if (!((IC_LEFT (dic) &&
2130              IC_RESULT (ic)->key == IC_LEFT (dic)->key) ||
2131             (IC_RIGHT (dic) &&
2132              IC_RESULT (ic)->key == IC_RIGHT (dic)->key)))
2133         return 0;
2134     }
2135 pack:
2136   /* found the definition */
2137   /* replace the result with the result of */
2138   /* this assignment and remove this assignment */
2139   bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2140
2141   IC_RESULT (dic) = IC_RESULT (ic);
2142
2143   if (IS_ITEMP (IC_RESULT (dic)) && OP_SYMBOL (IC_RESULT (dic))->liveFrom > dic->seq)
2144     {
2145       OP_SYMBOL (IC_RESULT (dic))->liveFrom = dic->seq;
2146     }
2147   /* delete from liverange table also
2148      delete from all the points inbetween and the new
2149      one */
2150   for (sic = dic; sic != ic; sic = sic->next)
2151     {
2152       bitVectUnSetBit (sic->rlive, IC_RESULT (ic)->key);
2153       if (IS_ITEMP (IC_RESULT (dic)))
2154         bitVectSetBit (sic->rlive, IC_RESULT (dic)->key);
2155     }
2156
2157   remiCodeFromeBBlock (ebp, ic);
2158   bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
2159   hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
2160   OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
2161   return 1;
2162 }
2163
2164 /*------------------------------------------------------------------*/
2165 /* findAssignToSym : scanning backwards looks for first assig found */
2166 /*------------------------------------------------------------------*/
2167 static iCode *
2168 findAssignToSym (operand * op, iCode * ic)
2169 {
2170   iCode *dic;
2171
2172   /* This routine is used to find sequences like
2173      iTempAA = FOO;
2174      ...;  (intervening ops don't use iTempAA or modify FOO)
2175      blah = blah + iTempAA;
2176
2177      and eliminate the use of iTempAA, freeing up its register for
2178      other uses.
2179   */
2180
2181   for (dic = ic->prev; dic; dic = dic->prev)
2182     {
2183
2184       /* if definition by assignment */
2185       if (dic->op == '=' &&
2186           !POINTER_SET (dic) &&
2187           IC_RESULT (dic)->key == op->key
2188 /*          &&  IS_TRUE_SYMOP(IC_RIGHT(dic)) */
2189         )
2190         {
2191
2192           /* we are interested only if defined in far space */
2193           /* or in stack space in case of + & - */
2194
2195           /* if assigned to a non-symbol then return
2196              FALSE */
2197           if (!IS_SYMOP (IC_RIGHT (dic)))
2198             return NULL;
2199
2200           /* if the symbol is in far space then
2201              we should not */
2202           if (isOperandInFarSpace (IC_RIGHT (dic)))
2203             return NULL;
2204
2205           /* for + & - operations make sure that
2206              if it is on the stack it is the same
2207              as one of the three operands */
2208           if ((ic->op == '+' || ic->op == '-') &&
2209               OP_SYMBOL (IC_RIGHT (dic))->onStack)
2210             {
2211
2212               if (IC_RESULT (ic)->key != IC_RIGHT (dic)->key &&
2213                   IC_LEFT (ic)->key != IC_RIGHT (dic)->key &&
2214                   IC_RIGHT (ic)->key != IC_RIGHT (dic)->key)
2215                 return NULL;
2216             }
2217
2218           break;
2219
2220         }
2221
2222       /* if we find an usage then we cannot delete it */
2223       if (IC_LEFT (dic) && IC_LEFT (dic)->key == op->key)
2224         return NULL;
2225
2226       if (IC_RIGHT (dic) && IC_RIGHT (dic)->key == op->key)
2227         return NULL;
2228
2229       if (POINTER_SET (dic) && IC_RESULT (dic)->key == op->key)
2230         return NULL;
2231     }
2232
2233   /* now make sure that the right side of dic
2234      is not defined between ic & dic */
2235   if (dic)
2236     {
2237       iCode *sic = dic->next;
2238
2239       for (; sic != ic; sic = sic->next)
2240         if (IC_RESULT (sic) &&
2241             IC_RESULT (sic)->key == IC_RIGHT (dic)->key)
2242           return NULL;
2243     }
2244
2245   return dic;
2246
2247
2248 }
2249
2250 /*-----------------------------------------------------------------*/
2251 /* packRegsForSupport :- reduce some registers for support calls   */
2252 /*-----------------------------------------------------------------*/
2253 static int
2254 packRegsForSupport (iCode * ic, eBBlock * ebp)
2255 {
2256   int change = 0;
2257
2258   /* for the left & right operand :- look to see if the
2259      left was assigned a true symbol in far space in that
2260      case replace them */
2261   if (IS_ITEMP (IC_LEFT (ic)) &&
2262       OP_SYMBOL (IC_LEFT (ic))->liveTo <= ic->seq)
2263     {
2264       iCode *dic = findAssignToSym (IC_LEFT (ic), ic);
2265       iCode *sic;
2266
2267       if (!dic)
2268         goto right;
2269
2270       /* found it we need to remove it from the
2271          block */
2272       for (sic = dic; sic != ic; sic = sic->next) {
2273         bitVectUnSetBit (sic->rlive, IC_LEFT (ic)->key);
2274         sic->rlive = bitVectSetBit (sic->rlive, IC_RIGHT (dic)->key);
2275       }
2276
2277       wassert(IS_SYMOP(IC_LEFT (ic)));
2278       wassert(IS_SYMOP(IC_RIGHT (dic)));
2279       IC_LEFT (ic)->operand.symOperand =
2280         IC_RIGHT (dic)->operand.symOperand;
2281       OP_SYMBOL(IC_LEFT(ic))->liveTo = ic->seq;
2282       IC_LEFT (ic)->key = IC_RIGHT (dic)->operand.symOperand->key;
2283       bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2284       remiCodeFromeBBlock (ebp, dic);
2285       hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2286       change++;
2287     }
2288
2289   /* do the same for the right operand */
2290 right:
2291   if (!change &&
2292       IS_ITEMP (IC_RIGHT (ic)) &&
2293       OP_SYMBOL (IC_RIGHT (ic))->liveTo <= ic->seq)
2294     {
2295       iCode *dic = findAssignToSym (IC_RIGHT (ic), ic);
2296       iCode *sic;
2297
2298       if (!dic)
2299         return change;
2300
2301       /* if this is a subtraction & the result
2302          is a true symbol in far space then don't pack */
2303       if (ic->op == '-' && IS_TRUE_SYMOP (IC_RESULT (dic)))
2304         {
2305           sym_link *etype = getSpec (operandType (IC_RESULT (dic)));
2306           if (IN_FARSPACE (SPEC_OCLS (etype)))
2307             return change;
2308         }
2309       /* found it we need to remove it from the
2310          block */
2311       for (sic = dic; sic != ic; sic = sic->next) {
2312         bitVectUnSetBit (sic->rlive, IC_RIGHT (ic)->key);
2313         sic->rlive = bitVectSetBit (sic->rlive, IC_RIGHT (dic)->key);
2314       }
2315
2316       wassert(IS_SYMOP(IC_RIGHT (ic)));
2317       wassert(IS_SYMOP(IC_RIGHT (dic)));
2318       IC_RIGHT (ic)->operand.symOperand =
2319         IC_RIGHT (dic)->operand.symOperand;
2320       IC_RIGHT (ic)->key = IC_RIGHT (dic)->operand.symOperand->key;
2321       OP_SYMBOL(IC_RIGHT(ic))->liveTo = ic->seq;
2322       remiCodeFromeBBlock (ebp, dic);
2323       bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2324       hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2325       change++;
2326     }
2327
2328   return change;
2329 }
2330
2331 #define IS_OP_RUONLY(x) (x && IS_SYMOP(x) && OP_SYMBOL(x)->ruonly)
2332
2333
2334 /*-----------------------------------------------------------------*/
2335 /* packRegsDPTRnuse - color live ranges that can go into extra DPTRS */
2336 /*-----------------------------------------------------------------*/
2337 static int packRegsDPTRnuse( operand *op , unsigned dptr)
2338 {
2339     int i,key;
2340     iCode *ic;
2341
2342     if (!IS_SYMOP(op) || !IS_ITEMP(op)) return 0;
2343     if (OP_SYMBOL(op)->remat || OP_SYMBOL(op)->ruonly || OP_SYMBOL(op)->dptr)
2344         return 0;
2345
2346     /* first check if any overlapping liverange has already been
2347        assigned to this DPTR */
2348     if (OP_SYMBOL(op)->clashes) {
2349         for (i = 0 ; i < OP_SYMBOL(op)->clashes->size ; i++ ) {
2350             symbol *sym;
2351             if (bitVectBitValue(OP_SYMBOL(op)->clashes,i)) {
2352                 sym = hTabItemWithKey(liveRanges,i);
2353                 if (sym->dptr == dptr) return 0;
2354             }
2355         }
2356     }
2357
2358     /* future for more dptrs */
2359     if (dptr > 1) {
2360         OP_SYMBOL(op)->dptr = dptr;
2361         return 1;
2362     }
2363
2364     /* DPTR1 is special since it is also used as a scratch by the backend .
2365        so we walk thru the entire live range of this operand and make sure
2366        DPTR1 will not be used by the backed . The logic here is to find out if
2367        more than one operand in an icode is in far space then we give up : we
2368        don't keep it live across functions for now
2369     */
2370
2371     ic = hTabFirstItemWK(iCodeSeqhTab,OP_SYMBOL(op)->liveFrom);
2372     for (; ic && ic->seq <= OP_SYMBOL(op)->liveTo;
2373          ic = hTabNextItem(iCodeSeqhTab,&key)) {
2374         int nfs =0;
2375
2376         if (ic->op == CALL || ic->op == PCALL) return 0;
2377
2378         /* single operand icode are ok */
2379         if (ic->op == IFX || ic->op == IPUSH)
2380             continue ;
2381
2382         if (ic->op == SEND ) {
2383             if (ic->argreg != 1 ) return 0;
2384             else continue ;
2385         }
2386         /* two special cases first */
2387         if (POINTER_GET(ic) && !isOperandEqual(IC_LEFT(ic),op)  && /* pointer get */
2388             !OP_SYMBOL(IC_LEFT(ic))->ruonly                     && /* with result in far space */
2389             (isOperandInFarSpace(IC_RESULT(ic)) &&
2390              !isOperandInReg(IC_RESULT(ic)))) {
2391             return 0;
2392         }
2393
2394         if (POINTER_SET(ic) && !isOperandEqual(IC_RESULT(ic),op)        && /* pointer set */
2395             !OP_SYMBOL(IC_RESULT(ic))->ruonly                           && /* with right in far space */
2396             (isOperandInFarSpace(IC_RIGHT(ic)) &&
2397              !isOperandInReg(IC_RIGHT(ic)))) {
2398             return 0;
2399         }
2400
2401         if (IC_RESULT(ic) && IS_SYMOP(IC_RESULT(ic))    && /* if symbol operand */
2402             !isOperandEqual(IC_RESULT(ic),op)           && /* not the same as this */
2403             ((isOperandInFarSpace(IC_RESULT(ic)) ||        /* in farspace or */
2404               OP_SYMBOL(IC_RESULT(ic))->onStack)        && /* on the stack   */
2405              !isOperandInReg(IC_RESULT(ic)))) {            /* and not in register */
2406             nfs++;
2407         }
2408         /* same for left */
2409         if (IC_LEFT(ic) && IS_SYMOP(IC_LEFT(ic))        && /* if symbol operand */
2410             !isOperandEqual(IC_LEFT(ic),op)             && /* not the same as this */
2411             ((isOperandInFarSpace(IC_LEFT(ic)) ||          /* in farspace or */
2412               OP_SYMBOL(IC_LEFT(ic))->onStack)          && /* on the stack   */
2413              !isOperandInReg(IC_LEFT(ic)))) {              /* and not in register */
2414             nfs++;
2415         }
2416         /* same for right */
2417         if (IC_RIGHT(ic) && IS_SYMOP(IC_RIGHT(ic))      && /* if symbol operand */
2418             !isOperandEqual(IC_RIGHT(ic),op)            && /* not the same as this */
2419             ((isOperandInFarSpace(IC_RIGHT(ic)) ||         /* in farspace or */
2420               OP_SYMBOL(IC_RIGHT(ic))->onStack)         && /* on the stack   */
2421              !isOperandInReg(IC_RIGHT(ic)))) {             /* and not in register */
2422             nfs++;
2423         }
2424
2425         // Check that no other ops in this range have been assigned to dptr1.
2426         // I don't understand why this is not caught by the first check, above.
2427         // But it isn't always, see bug 769624.
2428         if (IC_RESULT(ic) && IS_SYMOP(IC_RESULT(ic)) &&
2429             (OP_SYMBOL(IC_RESULT(ic))->dptr == 1))
2430         {
2431             //fprintf(stderr, "dptr1 already in use in live range #1\n");
2432             return 0;
2433         }
2434
2435         if (IC_LEFT(ic) && IS_SYMOP(IC_LEFT(ic)) &&
2436             (OP_SYMBOL(IC_LEFT(ic))->dptr == 1))
2437         {
2438             //fprintf(stderr, "dptr1 already in use in live range # 2\n");
2439             return 0;
2440         }
2441
2442         if (IC_RIGHT(ic) && IS_SYMOP(IC_RIGHT(ic)) &&
2443             (OP_SYMBOL(IC_RIGHT(ic))->dptr == 1))
2444         {
2445             //fprintf(stderr, "dptr1 already in use in live range # 3\n");
2446             return 0;
2447         }
2448
2449         if (nfs && IC_RESULT(ic) && IS_SYMOP(IC_RESULT(ic)) &&
2450             OP_SYMBOL(IC_RESULT(ic))->ruonly) return 0;
2451
2452         if (nfs > 1) return 0;
2453     }
2454     OP_SYMBOL(op)->dptr = dptr;
2455     return 1;
2456 }
2457
2458 /*-----------------------------------------------------------------*/
2459 /* packRegsDPTRuse : - will reduce some registers for single Use */
2460 /*-----------------------------------------------------------------*/
2461 static iCode *
2462 packRegsDPTRuse (operand * op)
2463 {
2464     /* go thru entire liveRange of this variable & check for
2465        other possible usage of DPTR , if we don't find it the
2466        assign this to DPTR (ruonly)
2467     */
2468     int i, key;
2469     symbol *sym;
2470     iCode *ic, *dic;
2471     sym_link *type, *etype;
2472
2473     if (!IS_SYMOP(op) || !IS_ITEMP(op)) return NULL;
2474     if (OP_SYMBOL(op)->remat || OP_SYMBOL(op)->ruonly) return NULL;
2475
2476     /* first check if any overlapping liverange has already been
2477        assigned to DPTR */
2478     if (OP_SYMBOL(op)->clashes) {
2479         for (i = 0 ; i < OP_SYMBOL(op)->clashes->size ; i++ ) {
2480             if (bitVectBitValue(OP_SYMBOL(op)->clashes,i)) {
2481                 sym = hTabItemWithKey(liveRanges,i);
2482                 if (sym->ruonly) return NULL ;
2483             }
2484         }
2485     }
2486
2487     /* no then go thru this guys live range */
2488     dic = ic = hTabFirstItemWK(iCodeSeqhTab,OP_SYMBOL(op)->liveFrom);
2489     for (; ic && ic->seq <= OP_SYMBOL(op)->liveTo;
2490          ic = hTabNextItem(iCodeSeqhTab,&key)) {
2491
2492         if (SKIP_IC3(ic)) continue;
2493
2494         /* if PCALL cannot be sure give up */
2495         if (ic->op == PCALL) return NULL;
2496
2497         /* if SEND & not the first parameter then giveup */
2498         if (ic->op == SEND && ic->argreg != 1 &&
2499             ((isOperandInFarSpace(IC_LEFT(ic))  && !isOperandInReg(IC_LEFT(ic))) ||
2500              isOperandEqual(op,IC_LEFT(ic)))) return NULL;
2501
2502         /* if CALL then make sure it is VOID || return value not used
2503            or the return value is assigned to this one */
2504         if (ic->op == CALL) {
2505             if (OP_SYMBOL(IC_RESULT(ic))->liveTo ==
2506                 OP_SYMBOL(IC_RESULT(ic))->liveFrom) continue ;
2507             etype = getSpec(type = operandType(IC_RESULT(ic)));
2508             if (getSize(type) == 0 || isOperandEqual(op,IC_RESULT(ic)))
2509                 continue ;
2510             return NULL ;
2511         }
2512
2513         /* special case of add with a [remat] */
2514         if (ic->op == '+' &&
2515             OP_SYMBOL(IC_LEFT(ic))->remat &&
2516             (isOperandInFarSpace(IC_RIGHT(ic)) &&
2517              !isOperandInReg(IC_RIGHT(ic)))) return NULL ;
2518
2519         /* special cases  */
2520         /* pointerGet */
2521         if (POINTER_GET(ic) && !isOperandEqual(IC_LEFT(ic),op) &&
2522             getSize(operandType(IC_LEFT(ic))) > 1 ) return NULL ;
2523
2524         /* pointerSet */
2525         if (POINTER_SET(ic) && !isOperandEqual(IC_RESULT(ic),op) &&
2526             getSize(operandType(IC_RESULT(ic))) > 1 ) return NULL;
2527
2528         /* conditionals can destroy 'b' - make sure B wont
2529            be used in this one*/
2530         if ((IS_CONDITIONAL(ic) || ic->op == '*' || ic->op == '/'  ||
2531              ic->op == LEFT_OP || ic->op == RIGHT_OP ) &&
2532             getSize(operandType(op)) > 3) return NULL;
2533
2534         /* if this is a cast to a bigger type */
2535         if (ic->op==CAST) {
2536           if (!IS_PTR(OP_SYM_TYPE(IC_RESULT(ic))) &&
2537               getSize(OP_SYM_TYPE(IC_RESULT(ic))) >
2538               getSize(OP_SYM_TYPE(IC_RIGHT(ic)))) {
2539             return 0;
2540           }
2541         }
2542
2543         /* general case */
2544         if (IC_RESULT(ic) && IS_SYMOP(IC_RESULT(ic)) &&
2545             !isOperandEqual(IC_RESULT(ic),op) &&
2546             ( ( ( isOperandInFarSpace(IC_RESULT(ic)) || OP_SYMBOL(IC_RESULT(ic))->onStack) &&
2547                 !isOperandInReg(IC_RESULT(ic))) ||
2548              OP_SYMBOL(IC_RESULT(ic))->ruonly)) return NULL;
2549
2550         if (IC_RIGHT(ic) && IS_SYMOP(IC_RIGHT(ic)) &&
2551             !isOperandEqual(IC_RIGHT(ic),op) &&
2552             (OP_SYMBOL(IC_RIGHT(ic))->liveTo >= ic->seq ||
2553              IS_TRUE_SYMOP(IC_RIGHT(ic))               ||
2554              OP_SYMBOL(IC_RIGHT(ic))->ruonly) &&
2555             ( ( isOperandInFarSpace(IC_RIGHT(ic)) || OP_SYMBOL(IC_RIGHT(ic))->onStack) &&
2556                 !isOperandInReg(IC_RIGHT(ic))) ) return NULL;
2557
2558         if (IC_LEFT(ic) && IS_SYMOP(IC_LEFT(ic)) &&
2559             !isOperandEqual(IC_LEFT(ic),op) &&
2560             (OP_SYMBOL(IC_LEFT(ic))->liveTo >= ic->seq ||
2561              IS_TRUE_SYMOP(IC_LEFT(ic))               ||
2562              OP_SYMBOL(IC_LEFT(ic))->ruonly) &&
2563             ( ( isOperandInFarSpace(IC_LEFT(ic)) || OP_SYMBOL(IC_LEFT(ic))->onStack) &&
2564                 !isOperandInReg(IC_LEFT(ic))) ) return NULL;
2565
2566         if (IC_LEFT(ic) && IC_RIGHT(ic) &&
2567             IS_ITEMP(IC_LEFT(ic)) && IS_ITEMP(IC_RIGHT(ic)) &&
2568             (isOperandInFarSpace(IC_LEFT(ic)) && !isOperandInReg(IC_LEFT(ic))) &&
2569             (isOperandInFarSpace(IC_RIGHT(ic)) && !isOperandInReg(IC_RIGHT(ic))))
2570             return NULL;
2571     }
2572     OP_SYMBOL(op)->ruonly = 1;
2573     if (OP_SYMBOL(op)->usl.spillLoc) {
2574         if (OP_SYMBOL(op)->spillA)
2575             OP_SYMBOL(op)->usl.spillLoc->allocreq--;
2576         OP_SYMBOL(op)->usl.spillLoc = NULL;
2577     }
2578     return dic;
2579 }
2580
2581 /*-----------------------------------------------------------------*/
2582 /* isBitwiseOptimizable - requirements of JEAN LOUIS VERN          */
2583 /*-----------------------------------------------------------------*/
2584 static bool
2585 isBitwiseOptimizable (iCode * ic)
2586 {
2587   sym_link *ltype = getSpec (operandType (IC_LEFT (ic)));
2588   sym_link *rtype = getSpec (operandType (IC_RIGHT (ic)));
2589
2590   /* bitwise operations are considered optimizable
2591      under the following conditions (Jean-Louis VERN)
2592
2593      x & lit
2594      bit & bit
2595      bit & x
2596      bit ^ bit
2597      bit ^ x
2598      x   ^ lit
2599      x   | lit
2600      bit | bit
2601      bit | x
2602    */
2603   if (IS_LITERAL (rtype) ||
2604       (IS_BITVAR (ltype) && IN_BITSPACE (SPEC_OCLS (ltype))))
2605     return TRUE;
2606   else
2607     return FALSE;
2608 }
2609
2610 /*-----------------------------------------------------------------*/
2611 /* packRegsForAccUse - pack registers for acc use                  */
2612 /*-----------------------------------------------------------------*/
2613 static void
2614 packRegsForAccUse (iCode * ic)
2615 {
2616   iCode *uic;
2617
2618   /* if this is an aggregate, e.g. a one byte char array */
2619   if (IS_AGGREGATE(operandType(IC_RESULT(ic)))) {
2620     return;
2621   }
2622
2623   /* if we are calling a reentrant function that has stack parameters */
2624   if (ic->op == CALL &&
2625        IFFUNC_ISREENT(operandType(IC_LEFT(ic))) &&
2626        FUNC_HASSTACKPARM(operandType(IC_LEFT(ic))))
2627       return;
2628
2629   if (ic->op == PCALL &&
2630        IFFUNC_ISREENT(operandType(IC_LEFT(ic))->next) &&
2631        FUNC_HASSTACKPARM(operandType(IC_LEFT(ic))->next))
2632       return;
2633
2634   /* if + or - then it has to be one byte result */
2635   if ((ic->op == '+' || ic->op == '-')
2636       && getSize (operandType (IC_RESULT (ic))) > 1)
2637     return;
2638
2639   /* if shift operation make sure right side is not a literal */
2640   if (ic->op == RIGHT_OP &&
2641       (isOperandLiteral (IC_RIGHT (ic)) ||
2642        getSize (operandType (IC_RESULT (ic))) > 1))
2643     return;
2644
2645   if (ic->op == LEFT_OP &&
2646       (isOperandLiteral (IC_RIGHT (ic)) ||
2647        getSize (operandType (IC_RESULT (ic))) > 1))
2648     return;
2649
2650   if (IS_BITWISE_OP (ic) &&
2651       getSize (operandType (IC_RESULT (ic))) > 1)
2652     return;
2653
2654
2655   /* has only one definition */
2656   if (bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) > 1)
2657     return;
2658
2659   /* has only one use */
2660   if (bitVectnBitsOn (OP_USES (IC_RESULT (ic))) > 1)
2661     return;
2662
2663   /* and the usage immediately follows this iCode */
2664   if (!(uic = hTabItemWithKey (iCodehTab,
2665                                bitVectFirstBit (OP_USES (IC_RESULT (ic))))))
2666     return;
2667
2668   if (ic->next != uic)
2669     return;
2670
2671   /* if it is a conditional branch then we definitely can */
2672   if (uic->op == IFX)
2673     goto accuse;
2674
2675   if (uic->op == JUMPTABLE)
2676     return;
2677
2678   /* if the usage is not is an assignment
2679      or an arithmetic / bitwise / shift operation then not */
2680   if (POINTER_SET (uic) &&
2681       getSize (aggrToPtr (operandType (IC_RESULT (uic)), FALSE)) > 1)
2682     return;
2683
2684   if (uic->op != '=' &&
2685       !IS_ARITHMETIC_OP (uic) &&
2686       !IS_BITWISE_OP (uic) &&
2687       uic->op != LEFT_OP &&
2688       uic->op != RIGHT_OP)
2689     return;
2690
2691   /* if used in ^ operation then make sure right is not a
2692      literl */
2693   if (uic->op == '^' && isOperandLiteral (IC_RIGHT (uic)))
2694     return;
2695
2696   /* if shift operation make sure right side is not a literal */
2697   if (uic->op == RIGHT_OP &&
2698       (isOperandLiteral (IC_RIGHT (uic)) ||
2699        getSize (operandType (IC_RESULT (uic))) > 1))
2700     return;
2701
2702   if (uic->op == LEFT_OP &&
2703       (isOperandLiteral (IC_RIGHT (uic)) ||
2704        getSize (operandType (IC_RESULT (uic))) > 1))
2705     return;
2706
2707   /* make sure that the result of this icode is not on the
2708      stack, since acc is used to compute stack offset */
2709   if (isOperandOnStack(IC_RESULT(uic)))
2710     return;
2711
2712   /* if either one of them in far space then we cannot */
2713   if ((IS_TRUE_SYMOP (IC_LEFT (uic)) &&
2714        isOperandInFarSpace (IC_LEFT (uic))) ||
2715       (IS_TRUE_SYMOP (IC_RIGHT (uic)) &&
2716        isOperandInFarSpace (IC_RIGHT (uic))))
2717     return;
2718
2719   /* if the usage has only one operand then we can */
2720   if (IC_LEFT (uic) == NULL ||
2721       IC_RIGHT (uic) == NULL)
2722     goto accuse;
2723
2724   /* make sure this is on the left side if not
2725      a '+' since '+' is commutative */
2726   if (ic->op != '+' &&
2727       IC_LEFT (uic)->key != IC_RESULT (ic)->key)
2728     return;
2729
2730   /* if the other one is not on stack then we can */
2731   if (IC_LEFT (uic)->key == IC_RESULT (ic)->key &&
2732       (IS_ITEMP (IC_RIGHT (uic)) ||
2733        (IS_TRUE_SYMOP (IC_RIGHT (uic)) &&
2734         !OP_SYMBOL (IC_RIGHT (uic))->onStack)))
2735     goto accuse;
2736
2737   if (IC_RIGHT (uic)->key == IC_RESULT (ic)->key &&
2738       (IS_ITEMP (IC_LEFT (uic)) ||
2739        (IS_TRUE_SYMOP (IC_LEFT (uic)) &&
2740         !OP_SYMBOL (IC_LEFT (uic))->onStack)))
2741     goto accuse;
2742
2743   return;
2744
2745 accuse:
2746   OP_SYMBOL (IC_RESULT (ic))->accuse = 1;
2747
2748 }
2749
2750 /*-----------------------------------------------------------------*/
2751 /* packForPush - hueristics to reduce iCode for pushing            */
2752 /*-----------------------------------------------------------------*/
2753 static void
2754 packForPush (iCode * ic, eBBlock * ebp)
2755 {
2756   iCode *dic, *lic;
2757   bitVect *dbv;
2758
2759   if ((ic->op != IPUSH && ic->op != SEND) || !IS_ITEMP (IC_LEFT (ic)))
2760     return;
2761
2762   /* must have only definition & one usage */
2763   if (bitVectnBitsOn (OP_DEFS (IC_LEFT (ic))) != 1 ||
2764       bitVectnBitsOn (OP_USES (IC_LEFT (ic))) != 1)
2765     return;
2766
2767   /* find the definition */
2768   if (!(dic = hTabItemWithKey (iCodehTab,
2769                                bitVectFirstBit (OP_DEFS (IC_LEFT (ic))))))
2770     return;
2771
2772   if (dic->op != '=' || POINTER_SET (dic))
2773     return;
2774
2775   if (dic->eBBlockNum != ic->eBBlockNum) return ;
2776
2777   /* make sure the right side does not have any definitions
2778      inbetween */
2779   dbv = OP_DEFS(IC_RIGHT(dic));
2780   for (lic = ic; lic && lic != dic ; lic = lic->prev) {
2781           if (bitVectBitValue(dbv,lic->key)) return ;
2782   }
2783   /* make sure they have the same type */
2784   if (IS_SPEC(operandType(IC_LEFT(ic))))
2785   {
2786     sym_link *itype=operandType(IC_LEFT(ic));
2787     sym_link *ditype=operandType(IC_RIGHT(dic));
2788
2789     if (SPEC_USIGN(itype)!=SPEC_USIGN(ditype) ||
2790         SPEC_LONG(itype)!=SPEC_LONG(ditype))
2791       return;
2792   }
2793   /* extend the live range of replaced operand if needed */
2794   if (OP_SYMBOL(IC_RIGHT(dic))->liveTo < OP_SYMBOL(IC_LEFT(ic))->liveTo) {
2795           OP_SYMBOL(IC_RIGHT(dic))->liveTo = OP_SYMBOL(IC_LEFT(ic))->liveTo;
2796           OP_SYMBOL(IC_RIGHT(dic))->clashes =
2797               bitVectUnion(OP_SYMBOL(IC_RIGHT(dic))->clashes,
2798                            OP_SYMBOL(IC_LEFT(ic))->clashes);
2799   }
2800   for (lic = ic; lic && lic != dic; lic = lic->prev)
2801     {
2802       bitVectUnSetBit (lic->rlive, IC_LEFT (ic)->key);
2803       if (IS_ITEMP (IC_RIGHT (dic)))
2804         bitVectSetBit (lic->rlive, IC_RIGHT (dic)->key);
2805     }
2806   /* we now we know that it has one & only one def & use
2807      and the that the definition is an assignment */
2808   IC_LEFT (ic) = IC_RIGHT (dic);
2809
2810   remiCodeFromeBBlock (ebp, dic);
2811   bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
2812   hTabDeleteItem (&iCodehTab, dic->key, dic, DELETE_ITEM, NULL);
2813 }
2814
2815 /*-----------------------------------------------------------------*/
2816 /* packRegisters - does some transformations to reduce register    */
2817 /*                   pressure                                      */
2818 /*-----------------------------------------------------------------*/
2819 static void
2820 packRegisters (eBBlock * ebp)
2821 {
2822   iCode *ic;
2823   int change = 0;
2824
2825   while (1)
2826     {
2827
2828       change = 0;
2829
2830       /* look for assignments of the form */
2831       /* iTempNN = TRueSym (someoperation) SomeOperand */
2832       /*       ....                       */
2833       /* TrueSym := iTempNN:1             */
2834       for (ic = ebp->sch; ic; ic = ic->next)
2835         {
2836           /* find assignment of the form TrueSym := iTempNN:1 */
2837           if (ic->op == '=' && !POINTER_SET (ic))
2838             change += packRegsForAssign (ic, ebp);
2839         }
2840
2841       if (!change)
2842         break;
2843     }
2844
2845   for (ic = ebp->sch; ic; ic = ic->next)
2846     {
2847       /* if this is an itemp & result of an address of a true sym
2848          then mark this as rematerialisable   */
2849       if (ic->op == ADDRESS_OF &&
2850           IS_ITEMP (IC_RESULT (ic)) &&
2851           IS_TRUE_SYMOP (IC_LEFT (ic)) &&
2852           bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
2853           !OP_SYMBOL (IC_LEFT (ic))->onStack)
2854         {
2855
2856           OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2857           OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2858           OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2859
2860         }
2861
2862         /* if this is an itemp & used as a pointer
2863            & assigned to a literal then remat */
2864         if (IS_ASSIGN_ICODE(ic) &&
2865             IS_ITEMP(IC_RESULT(ic)) &&
2866             bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
2867             isOperandLiteral(IC_RIGHT(ic)))
2868         {
2869           OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2870           OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2871           OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2872         }
2873
2874       /* if straight assignment then carry remat flag if
2875          this is the only definition */
2876       if (ic->op == '=' &&
2877           !POINTER_SET (ic) &&
2878           IS_SYMOP (IC_RIGHT (ic)) &&
2879           OP_SYMBOL (IC_RIGHT (ic))->remat &&
2880           !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode) &&
2881           bitVectnBitsOn (OP_SYMBOL (IC_RESULT (ic))->defs) <= 1)
2882         {
2883
2884           OP_SYMBOL (IC_RESULT (ic))->remat =
2885             OP_SYMBOL (IC_RIGHT (ic))->remat;
2886           OP_SYMBOL (IC_RESULT (ic))->rematiCode =
2887             OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
2888         }
2889
2890       /* if cast to a generic pointer & the pointer being
2891          cast is remat, then we can remat this cast as well */
2892       if (ic->op == CAST &&
2893           IS_SYMOP(IC_RIGHT(ic)) &&
2894           !OP_SYMBOL(IC_RESULT(ic))->isreqv &&
2895           OP_SYMBOL(IC_RIGHT(ic))->remat ) {
2896               sym_link *to_type = operandType(IC_LEFT(ic));
2897               sym_link *from_type = operandType(IC_RIGHT(ic));
2898               if (IS_GENPTR(to_type) && IS_PTR(from_type)) {
2899                       OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2900                       OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2901                       OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2902               }
2903       }
2904
2905       /* if this is a +/- operation with a rematerizable
2906          then mark this as rematerializable as well */
2907       if ((ic->op == '+' || ic->op == '-') &&
2908           (IS_SYMOP (IC_LEFT (ic)) &&
2909            IS_ITEMP (IC_RESULT (ic)) &&
2910            OP_SYMBOL (IC_LEFT (ic))->remat &&
2911            (!IS_SYMOP (IC_RIGHT (ic)) || !IS_CAST_ICODE(OP_SYMBOL (IC_RIGHT (ic))->rematiCode)) &&
2912            bitVectnBitsOn (OP_DEFS (IC_RESULT (ic))) == 1 &&
2913            IS_OP_LITERAL (IC_RIGHT (ic))))
2914         {
2915
2916           //int i = operandLitValue(IC_RIGHT(ic));
2917           OP_SYMBOL (IC_RESULT (ic))->remat = 1;
2918           OP_SYMBOL (IC_RESULT (ic))->rematiCode = ic;
2919           OP_SYMBOL (IC_RESULT (ic))->usl.spillLoc = NULL;
2920         }
2921
2922       /* mark the pointer usages */
2923       if (POINTER_SET (ic) && IS_SYMOP (IC_RESULT (ic)))
2924         OP_SYMBOL (IC_RESULT (ic))->uptr = 1;
2925
2926       if (POINTER_GET (ic) && IS_SYMOP (IC_LEFT (ic)))
2927         OP_SYMBOL (IC_LEFT (ic))->uptr = 1;
2928
2929       if (ic->op == RETURN && IS_SYMOP (IC_LEFT(ic)))
2930           OP_SYMBOL (IC_LEFT (ic))->uptr = 1;
2931
2932       if (ic->op == RECEIVE && ic->argreg == 1 &&
2933           IS_SYMOP (IC_RESULT (ic)) &&
2934           getSize (operandType(IC_RESULT(ic))) <= 3)
2935           OP_SYMBOL (IC_RESULT(ic))->uptr = 1;
2936
2937       if (ic->op == SEND && ic->argreg == 1 &&
2938           IS_SYMOP(IC_LEFT(ic)) &&
2939           getSize (aggrToPtr(operandType(IC_LEFT(ic)),FALSE)) <= 3)
2940           OP_SYMBOL (IC_LEFT(ic))->uptr = 1;
2941
2942       if (!SKIP_IC2 (ic))
2943         {
2944           /* if we are using a symbol on the stack
2945              then we should say ds390_ptrRegReq */
2946           if (options.useXstack && ic->parmPush
2947               && (ic->op == IPUSH || ic->op == IPOP))
2948             ds390_ptrRegReq++;
2949           if (ic->op == IFX && IS_SYMOP (IC_COND (ic)))
2950                   ds390_ptrRegReq += ((OP_SYMBOL (IC_COND (ic))->onStack ? !options.stack10bit : 0) +
2951                                       OP_SYMBOL (IC_COND (ic))->iaccess +
2952                                       (SPEC_OCLS(OP_SYMBOL (IC_COND (ic))->etype) == idata));
2953           else if (ic->op == JUMPTABLE && IS_SYMOP (IC_JTCOND (ic)))
2954                   ds390_ptrRegReq += ((OP_SYMBOL (IC_JTCOND (ic))->onStack ? !options.stack10bit : 0) +
2955                                       OP_SYMBOL (IC_JTCOND (ic))->iaccess +
2956                                       (SPEC_OCLS(OP_SYMBOL (IC_JTCOND (ic))->etype) == idata));
2957           else
2958             {
2959               if (IS_SYMOP (IC_LEFT (ic)))
2960                       ds390_ptrRegReq += ((OP_SYMBOL (IC_LEFT (ic))->onStack ? !options.stack10bit : 0) +
2961                                           OP_SYMBOL (IC_LEFT (ic))->iaccess +
2962                                           (SPEC_OCLS(OP_SYMBOL (IC_LEFT (ic))->etype) == idata));
2963               if (IS_SYMOP (IC_RIGHT (ic)))
2964                       ds390_ptrRegReq += ((OP_SYMBOL (IC_RIGHT (ic))->onStack ? !options.stack10bit : 0) +
2965                                           OP_SYMBOL (IC_RIGHT (ic))->iaccess +
2966                                           (SPEC_OCLS(OP_SYMBOL (IC_RIGHT (ic))->etype) == idata));
2967               if (IS_SYMOP (IC_RESULT (ic)))
2968                       ds390_ptrRegReq += ((OP_SYMBOL (IC_RESULT (ic))->onStack ? !options.stack10bit : 0) +
2969                                           OP_SYMBOL (IC_RESULT (ic))->iaccess +
2970                                           (SPEC_OCLS(OP_SYMBOL (IC_RESULT (ic))->etype) == idata));
2971             }
2972         }
2973
2974       /* if the condition of an if instruction
2975          is defined in the previous instruction and
2976          this is the only usage then
2977          mark the itemp as a conditional */
2978       if ((IS_CONDITIONAL (ic) ||
2979            (IS_BITWISE_OP(ic) && isBitwiseOptimizable (ic))) &&
2980           ic->next && ic->next->op == IFX &&
2981           bitVectnBitsOn (OP_USES(IC_RESULT(ic)))==1 &&
2982           isOperandEqual (IC_RESULT (ic), IC_COND (ic->next)) &&
2983           OP_SYMBOL (IC_RESULT (ic))->liveTo <= ic->next->seq)
2984         {
2985           OP_SYMBOL (IC_RESULT (ic))->regType = REG_CND;
2986           continue;
2987         }
2988 #if 1
2989       /* reduce for support function calls */
2990       if (ic->supportRtn || ic->op == '+' || ic->op == '-')
2991         packRegsForSupport (ic, ebp);
2992 #endif
2993       /* some cases the redundant moves can
2994          can be eliminated for return statements . Can be elminated for the first SEND */
2995       if ((ic->op == RETURN ||
2996            ((ic->op == SEND || ic->op == RECEIVE)&& ic->argreg == 1)) &&
2997           !isOperandInFarSpace (IC_LEFT (ic)) &&
2998           !options.model) {
2999
3000           packRegsDPTRuse (IC_LEFT (ic));
3001       }
3002
3003       if (ic->op == CALL) {
3004           sym_link *ftype = operandType(IC_LEFT(ic));
3005           if (getSize(operandType(IC_RESULT(ic))) <= 4 &&
3006               !IFFUNC_ISBUILTIN(ftype)) {
3007               packRegsDPTRuse (IC_RESULT (ic));
3008           }
3009       }
3010
3011       /* if pointer set & left has a size more than
3012          one and right is not in far space */
3013       if (POINTER_SET (ic) &&
3014           !isOperandInFarSpace (IC_RIGHT (ic)) &&
3015           IS_SYMOP (IC_RESULT (ic)) &&
3016           !OP_SYMBOL (IC_RESULT (ic))->remat &&
3017           !IS_OP_RUONLY (IC_RIGHT (ic)) &&
3018           getSize (aggrToPtr (operandType (IC_RESULT (ic)), FALSE)) > 1) {
3019
3020           packRegsDPTRuse (IC_RESULT (ic));
3021       }
3022
3023       /* if pointer get */
3024       if (POINTER_GET (ic) &&
3025           !isOperandInFarSpace (IC_RESULT (ic)) &&
3026           IS_SYMOP (IC_LEFT (ic)) &&
3027           !OP_SYMBOL (IC_LEFT (ic))->remat &&
3028           !IS_OP_RUONLY (IC_RESULT (ic)) &&
3029           getSize (aggrToPtr (operandType (IC_LEFT (ic)), FALSE)) > 1) {
3030
3031           packRegsDPTRuse (IC_LEFT (ic));
3032       }
3033
3034       /* if this is cast for intergral promotion then
3035          check if only use of  the definition of the
3036          operand being casted/ if yes then replace
3037          the result of that arithmetic operation with
3038          this result and get rid of the cast */
3039       if (ic->op == CAST)
3040         {
3041           sym_link *fromType = operandType (IC_RIGHT (ic));
3042           sym_link *toType = operandType (IC_LEFT (ic));
3043
3044           if (IS_INTEGRAL (fromType) && IS_INTEGRAL (toType) &&
3045               getSize (fromType) != getSize (toType) &&
3046               SPEC_USIGN (fromType) == SPEC_USIGN (toType))
3047             {
3048
3049               iCode *dic = packRegsDPTRuse (IC_RIGHT (ic));
3050               if (dic)
3051                 {
3052                   if (IS_ARITHMETIC_OP (dic))
3053                     {
3054                       bitVectUnSetBit(OP_SYMBOL(IC_RESULT(dic))->defs,dic->key);
3055                       IC_RESULT (dic) = IC_RESULT (ic);
3056                       remiCodeFromeBBlock (ebp, ic);
3057                       bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
3058                       hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
3059                       OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
3060                       ic = ic->prev;
3061                     }
3062                   else
3063                     OP_SYMBOL (IC_RIGHT (ic))->ruonly = 0;
3064                 }
3065             }
3066           else
3067             {
3068
3069               /* if the type from and type to are the same
3070                  then if this is the only use then packit */
3071               if (compareType (operandType (IC_RIGHT (ic)),
3072                              operandType (IC_LEFT (ic))) == 1)
3073                 {
3074                   iCode *dic = packRegsDPTRuse (IC_RIGHT (ic));
3075                   if (dic)
3076                     {
3077                       bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
3078                       IC_RESULT (dic) = IC_RESULT (ic);
3079                       remiCodeFromeBBlock (ebp, ic);
3080                       bitVectUnSetBit(OP_SYMBOL(IC_RESULT(ic))->defs,ic->key);
3081                       hTabDeleteItem (&iCodehTab, ic->key, ic, DELETE_ITEM, NULL);
3082                       OP_DEFS(IC_RESULT (dic))=bitVectSetBit (OP_DEFS (IC_RESULT (dic)), dic->key);
3083                       ic = ic->prev;
3084                     }
3085                 }
3086             }
3087         }
3088
3089       /* pack for PUSH
3090          iTempNN := (some variable in farspace) V1
3091          push iTempNN ;
3092          -------------
3093          push V1
3094        */
3095       if (ic->op == IPUSH || ic->op == SEND)
3096         {
3097           packForPush (ic, ebp);
3098         }
3099
3100
3101       /* pack registers for accumulator use, when the
3102          result of an arithmetic or bit wise operation
3103          has only one use, that use is immediately following
3104          the defintion and the using iCode has only one
3105          operand or has two operands but one is literal &
3106          the result of that operation is not on stack then
3107          we can leave the result of this operation in acc:b
3108          combination */
3109       if ((IS_ARITHMETIC_OP (ic)
3110            || IS_CONDITIONAL(ic)
3111            || IS_BITWISE_OP (ic)
3112            || ic->op == LEFT_OP || ic->op == RIGHT_OP
3113            || (ic->op == ADDRESS_OF && isOperandOnStack (IC_LEFT (ic)))
3114           ) &&
3115           IS_ITEMP (IC_RESULT (ic)) &&
3116           getSize (operandType (IC_RESULT (ic))) <= 2)
3117
3118         packRegsForAccUse (ic);
3119
3120     }
3121 }
3122
3123 /*-----------------------------------------------------------------*/
3124 /* assignRegisters - assigns registers to each live range as need  */
3125 /*-----------------------------------------------------------------*/
3126 void
3127 ds390_assignRegisters (eBBlock ** ebbs, int count)
3128 {
3129   iCode *ic;
3130   int i;
3131
3132   setToNull ((void *) &_G.funcrUsed);
3133   setToNull ((void *) &_G.regAssigned);
3134   setToNull ((void *) &_G.totRegAssigned);
3135   setToNull ((void *) &_G.funcrUsed);
3136   ds390_ptrRegReq = _G.stackExtend = _G.dataExtend = 0;
3137   ds390_nRegs = 12;
3138   if (options.model != MODEL_FLAT24) options.stack10bit = 0;
3139   /* change assignments this will remove some
3140      live ranges reducing some register pressure */
3141   for (i = 0; i < count; i++)
3142     packRegisters (ebbs[i]);
3143
3144   /* liveranges probably changed by register packing
3145      so we compute them again */
3146   recomputeLiveRanges (ebbs, count);
3147
3148   if (options.dump_pack)
3149     dumpEbbsToFileExt (DUMP_PACK, ebbs, count);
3150
3151   /* first determine for each live range the number of
3152      registers & the type of registers required for each */
3153   regTypeNum ();
3154
3155   /* and serially allocate registers */
3156   serialRegAssign (ebbs, count);
3157
3158   ds390_nRegs = 8;
3159   freeAllRegs ();
3160   fillGaps();
3161   ds390_nRegs = 12;
3162
3163   /* if stack was extended then tell the user */
3164   if (_G.stackExtend)
3165     {
3166 /*      werror(W_TOOMANY_SPILS,"stack", */
3167 /*             _G.stackExtend,currFunc->name,""); */
3168       _G.stackExtend = 0;
3169     }
3170
3171   if (_G.dataExtend)
3172     {
3173 /*      werror(W_TOOMANY_SPILS,"data space", */
3174 /*             _G.dataExtend,currFunc->name,""); */
3175       _G.dataExtend = 0;
3176     }
3177
3178   /* after that create the register mask
3179      for each of the instruction */
3180   createRegMask (ebbs, count);
3181
3182   /* redo that offsets for stacked automatic variables */
3183   if (currFunc)
3184     redoStackOffsets ();
3185
3186   /* make sure r0 & r1 are flagged as used if they might be used */
3187   /* as pointers */
3188   if (currFunc && ds390_ptrRegReq)
3189     {
3190       currFunc->regsUsed = bitVectSetBit (currFunc->regsUsed, R0_IDX);
3191       currFunc->regsUsed = bitVectSetBit (currFunc->regsUsed, R1_IDX);
3192     }
3193
3194   if (options.dump_rassgn) {
3195     dumpEbbsToFileExt (DUMP_RASSGN, ebbs, count);
3196     dumpLiveRanges (DUMP_LRANGE, liveRanges);
3197   }
3198
3199   /* do the overlaysegment stuff SDCCmem.c */
3200   doOverlays (ebbs, count);
3201
3202   /* now get back the chain */
3203   ic = iCodeLabelOptimize (iCodeFromeBBlock (ebbs, count));
3204
3205   gen390Code (ic);
3206
3207   /* free up any _G.stackSpil locations allocated */
3208   applyToSet (_G.stackSpil, deallocStackSpil);
3209   _G.slocNum = 0;
3210   setToNull ((void *) &_G.stackSpil);
3211   setToNull ((void *) &_G.spiltSet);
3212   /* mark all registers as free */
3213   ds390_nRegs = 8;
3214   freeAllRegs ();
3215
3216   return;
3217 }