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

   1 /*-------------------------------------------------------------------------
   2
   3   SDCClrange.c - source file for live range computations
   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 "limits.h"
  28
  29 int iCodeSeq = 0;
  30 hTab *liveRanges = NULL;
  31 hTab *iCodehTab = NULL;
  32 hTab *iCodeSeqhTab = NULL;
  33
  34 /*-----------------------------------------------------------------*/
  35 /* sequenceiCode - creates a sequence number for the iCode & add   */
  36 /*-----------------------------------------------------------------*/
  37 void
  38 sequenceiCode (eBBlock ** ebbs, int count)
  39 {
  40   int i;
  41
  42   for (i = 0; i < count; i++)
  43     {
  44
  45       iCode *ic;
  46       ebbs[i]->fSeq = iCodeSeq + 1;
  47       for (ic = ebbs[i]->sch; ic; ic = ic->next)
  48         {
  49           ic->seq = ++iCodeSeq;
  50           ic->depth = ebbs[i]->depth;
  51           hTabAddItem (&iCodehTab, ic->key, ic);
  52           hTabAddItem (&iCodeSeqhTab, ic->seq, ic);
  53         }
  54       ebbs[i]->lSeq = iCodeSeq;
  55     }
  56 }
  57
  58 /*-----------------------------------------------------------------*/
  59 /* markVisited - will set the visited flag for the given Block     */
  60 /*-----------------------------------------------------------------*/
  61 DEFSETFUNC (markVisited)
  62 {
  63   eBBlock *ebp = item;
  64
  65   if (ebp->visited)
  66     return 0;
  67   ebp->visited = 1;
  68   applyToSet (ebp->succList, markVisited);
  69   return 0;
  70 }
  71
  72 /*-----------------------------------------------------------------*/
  73 /* isOpAlive - checks to see if the usage in this block is the     */
  74 /*             uses the same definitions as this one               */
  75 /*-----------------------------------------------------------------*/
  76 DEFSETFUNC (isOpAlive)
  77 {
  78   eBBlock *ebp = item;
  79   V_ARG (operand *, op);
  80   V_ARG (eBBlock *, orig);
  81   V_ARG (iCode *, ic);
  82
  83   if (ebp->visited)
  84     return 0;
  85
  86   ebp->visited = 1;
  87
  88   /* if we have reached the originating block */
  89   /* or this block has some definiton for it  */
  90   /* then check if it is used between start & */
  91   /* this point */
  92   if (ebp == orig ||
  93       bitVectBitsInCommon (OP_DEFS (op), ebp->defSet))
  94     if (usedBetweenPoints (op, ebp->sch, ic))
  95       return 1;
  96     else
  97       {
  98         applyToSet (ebp->succList, markVisited);
  99         return 0;
 100       }
 101   else
 102     /* choosing this more expensive one since
 103        killDeadCode will take away some definitions
 104        but there is not way right now to take away
 105        the usage information for the corresponding
 106        usages, this will lead to longer live ranges */
 107   if (usedInRemaining (op, ebp->sch))
 108     return 1;
 109
 110
 111   return (applyToSet (ebp->succList, isOpAlive, op, orig, ic));
 112 }
 113
 114 /*-----------------------------------------------------------------*/
 115 /* isLastUse - return TRUE if no usage of this operand after this  */
 116 /*-----------------------------------------------------------------*/
 117 int
 118 isLastUse (operand * op, eBBlock * ebp, iCode * ic,
 119            eBBlock ** ebbs, int count)
 120 {
 121   int i;
 122
 123   /* if this is used in the remaining */
 124   if (usedInRemaining (op, ic))
 125     return 0;
 126
 127   /* if not then check any of the successor blocks use it */
 128   for (i = 0; i < count; ebbs[i++]->visited = 0);
 129   if (applyToSet (ebp->succList, isOpAlive, op, ebp, ic))
 130     return 0;
 131
 132   /* this is the last use */
 133   return 1;
 134 }
 135
 136 /*-----------------------------------------------------------------*/
 137 /* unionDefsUsed - unions the defsUsed in a block                  */
 138 /*-----------------------------------------------------------------*/
 139 DEFSETFUNC (unionDefsUsed)
 140 {
 141   eBBlock *ebp = item;
 142   V_ARG (bitVect **, bvp);
 143
 144   if (ebp->visited)
 145     return 0;
 146
 147   ebp->visited = 1;
 148
 149   *bvp = bitVectUnion (*bvp, ebp->usesDefs);
 150   applyToSet (ebp->succList, unionDefsUsed, bvp);
 151   return 0;
 152 }
 153
 154 /*-----------------------------------------------------------------*/
 155 /* setFromRange - sets the from range of a given operand           */
 156 /*-----------------------------------------------------------------*/
 157 void
 158 setFromRange (operand * op, int from)
 159 {
 160   /* only for compiler defined temporaries */
 161   if (!IS_ITEMP (op))
 162     return;
 163
 164   hTabAddItemIfNotP (&liveRanges, op->key, OP_SYMBOL (op));
 165
 166   if (op->isaddr)
 167     OP_SYMBOL (op)->isptr = 1;
 168
 169   if (!OP_LIVEFROM (op) ||
 170       OP_LIVEFROM (op) > from)
 171     OP_LIVEFROM (op) = from;
 172 }
 173
 174 /*-----------------------------------------------------------------*/
 175 /* setToRange - set the range to for an operand                    */
 176 /*-----------------------------------------------------------------*/
 177 void
 178 setToRange (operand * op, int to, bool check)
 179 {
 180   /* only for compiler defined temps */
 181   if (!IS_ITEMP (op))
 182     return;
 183
 184   OP_SYMBOL (op)->key = op->key;
 185   hTabAddItemIfNotP (&liveRanges, op->key, OP_SYMBOL (op));
 186
 187   if (op->isaddr)
 188     OP_SYMBOL (op)->isptr = 1;
 189
 190   if (check)
 191     if (!OP_LIVETO (op))
 192       OP_LIVETO (op) = to;
 193     else;
 194   else
 195     OP_LIVETO (op) = to;
 196 }
 197
 198 /*-----------------------------------------------------------------*/
 199 /* firstDeOf - finds the first definition in seq for op            */
 200 /*-----------------------------------------------------------------*/
 201 static iCode *
 202 firstDefOf (operand * op)
 203 {
 204   int i;
 205   iCode *ric = NULL, *lic = NULL;
 206   int fSeq = INT_MAX;
 207
 208   if (!OP_DEFS (op))
 209     return NULL;
 210
 211   for (i = 0; i < OP_DEFS (op)->size; i++)
 212     {
 213       if (bitVectBitValue (OP_DEFS (op), i) &&
 214           (lic = hTabItemWithKey (iCodehTab, i)) &&
 215           lic->seq < fSeq)
 216         {
 217
 218           fSeq = lic->seq;
 219           ric = lic;
 220         }
 221     }
 222   return ric;
 223 }
 224 /*-----------------------------------------------------------------*/
 225 /* useDefLoopCheck - check for uses before init inside loops       */
 226 /*-----------------------------------------------------------------*/
 227 static void
 228 useDefLoopCheck (operand * op, iCode * ic)
 229 {
 230   /* this is for situations like the following
 231      int a,b;
 232
 233      while (...) {
 234      a = ... ;
 235      ...
 236      _some_usage_of_b_;
 237      ...
 238      b = ... ;
 239      }
 240      in this case the definition of 'b' will flow to the usages
 241      but register allocator cannot handle these situations.so
 242      will mark as spilt */
 243
 244   int i = 0, fdSeq;
 245   int er = 0;
 246   iCode *tic;
 247
 248   /* get the first definition */
 249   if (!(tic = firstDefOf (op)))
 250     return;
 251
 252   fdSeq = tic->seq;
 253   /* now go thru the usages & make sure they follow
 254      the first definition */
 255   for (i = 0; i <= OP_USES (op)->size; i++)
 256     {
 257       if (bitVectBitValue (OP_USES (op), i) &&
 258           (tic = hTabItemWithKey (iCodehTab, i)) &&
 259           tic->seq < fdSeq)
 260         {
 261           er = 1;
 262           break;
 263         }
 264     }
 265
 266   /* found a usage without definition */
 267   if (er)
 268     {
 269       if (OP_SYMBOL (op)->isreqv && SPIL_LOC (op))
 270         {
 271
 272           werror (W_LOCAL_NOINIT,
 273                   SPIL_LOC (op)->name,
 274                   ic->filename, ic->lineno);
 275         }
 276       else
 277         {
 278
 279           werror (W_LOCAL_NOINIT,
 280                   OP_SYMBOL (op)->name,
 281                   ic->filename, ic->lineno);
 282         }
 283       OP_SYMBOL (op)->isspilt = 1;
 284     }
 285 }
 286
 287
 288 /*-----------------------------------------------------------------*/
 289 /* operandLUse - check and set the last use for a given operand    */
 290 /*-----------------------------------------------------------------*/
 291 operand *
 292 operandLUse (operand * op, eBBlock ** ebbs,
 293              int count, iCode * ic, eBBlock * ebp)
 294 {
 295   setFromRange (op, ic->seq);
 296   if (ic->depth)
 297     OP_SYMBOL (op)->used += (((unsigned int) 1 << ic->depth) + 1);
 298   else
 299     OP_SYMBOL (op)->used += 1;
 300
 301   if (isLastUse (op, ebp, ic->next, ebbs, count) ||
 302       (OP_LIVETO (op) && OP_LIVETO (op) < ic->seq))
 303     {
 304       int torange = ic->seq;
 305
 306       /* if this is a SEND then the toRange should be extended
 307          to the call */
 308       if (ic->op == SEND) {
 309           iCode *lic ;
 310           for (lic = ic->next ; lic ; lic = lic->next) {
 311               if (lic->op == CALL || lic->op == PCALL) break;
 312           }
 313           /* found it : mark */
 314           if (lic) torange = lic->prev->seq;
 315       }
 316       /* if this is the last use then if this block belongs
 317          to a  loop &  some definition  comes into the loop
 318          then extend the live range to  the end of the loop */
 319       if (ebp->partOfLoop
 320           && hasIncomingDefs (ebp->partOfLoop, op))
 321         {
 322           torange = findLoopEndSeq (ebp->partOfLoop);
 323         }
 324
 325       op = operandFromOperand (op);
 326       setToRange (op, torange, FALSE);
 327     }
 328   ic->uses = bitVectSetBit (ic->uses, op->key);
 329
 330   if (!OP_SYMBOL (op)->udChked)
 331     {
 332       sym_link *type = operandType (op);
 333       sym_link *etype = getSpec (type);
 334
 335       OP_SYMBOL (op)->udChked = 1;
 336       /* good place to check if unintialised */
 337       if ((IS_TRUE_SYMOP (op) || OP_SYMBOL (op)->isreqv) &&
 338           OP_SYMBOL (op)->islocal &&
 339           !IS_AGGREGATE (type) &&
 340           !IS_FUNC (type) &&
 341           ic->op != ADDRESS_OF &&
 342           !IS_STATIC (etype))
 343         {
 344
 345           if (bitVectIsZero (op->usesDefs))
 346             {
 347               OP_SYMBOL (op)->isspilt = 1;
 348
 349               if (OP_SYMBOL (op)->isreqv &&
 350                   !OP_SYMBOL (op)->_isparm && SPIL_LOC (op))
 351                 {
 352
 353                   werror (W_LOCAL_NOINIT,
 354                           SPIL_LOC (op)->name,
 355                           ic->filename, ic->lineno);
 356                 }
 357               else
 358                 {
 359
 360                   werror (W_LOCAL_NOINIT,
 361                           OP_SYMBOL (op)->name,
 362                           ic->filename, ic->lineno);
 363                 }
 364             }
 365           else
 366             {
 367               if (ebp->depth && op->usesDefs &&
 368                   !OP_SYMBOL (op)->_isparm)
 369                 {
 370                   /* check non-inits inside loops */
 371                   useDefLoopCheck (op, ic);
 372                 }
 373             }
 374         }
 375     }
 376   return op;
 377 }
 378
 379 /*-----------------------------------------------------------------*/
 380 /* killAllAlive - mark all the definitions living with this seq    */
 381 /*-----------------------------------------------------------------*/
 382 void
 383 killAllAlive (int seq)
 384 {
 385   symbol *sym;
 386   int k;
 387
 388   for (sym = hTabFirstItem (liveRanges, &k); sym;
 389        sym = hTabNextItem (liveRanges, &k))
 390     if (!sym->liveTo || (sym->liveTo < sym->liveFrom))
 391       sym->liveTo = seq;
 392 }
 393 /*-----------------------------------------------------------------*/
 394 /* defUsedAfterLoop - all definitions & usages before sequence num */
 395 /*-----------------------------------------------------------------*/
 396 bool
 397 defUsedAfterLoop (operand * op, int seq)
 398 {
 399   int i;
 400   iCode *ic;
 401
 402   /* check for the usages first */
 403   if (OP_SYMBOL (op)->uses && !bitVectIsZero (OP_SYMBOL (op)->uses))
 404     {
 405       for (i = 0; i < OP_SYMBOL (op)->uses->size; i++)
 406         {
 407
 408           if (bitVectBitValue (OP_SYMBOL (op)->uses, i) &&      /* usage found */
 409               (ic = hTabItemWithKey (iCodehTab, i)) &&  /*    ""       */
 410               ic->seq > seq)    /* & is after the seq */
 411             return TRUE;
 412         }
 413     }
 414
 415   return FALSE;
 416 }
 417
 418 /*-----------------------------------------------------------------*/
 419 /* markLiveRanges - for each operand mark the liveFrom & liveTo    */
 420 /*-----------------------------------------------------------------*/
 421 void
 422 markLiveRanges (eBBlock * ebp, eBBlock ** ebbs, int count)
 423 {
 424   iCode *ic;
 425   bitVect *defsUsed = NULL;
 426   bitVect *defsNotUsed = NULL;
 427   int i;
 428   /* for all the instructions */
 429   for (ic = ebp->sch; ic; ic = ic->next)
 430     {
 431
 432       if (ic->op == CALL || ic->op == PCALL)
 433         {
 434           setFromRange (IC_RESULT (ic), ic->seq);
 435           /* if the result has no usage then
 436              mark this as the end of its life too
 437              and take it away from the defs for the block */
 438           if (bitVectIsZero (OP_SYMBOL (IC_RESULT (ic))->uses))
 439             {
 440               setToRange (IC_RESULT (ic), ic->seq, FALSE);
 441               bitVectUnSetBit (ebp->defSet, ic->key);
 442             }
 443         }
 444
 445       if (SKIP_IC2 (ic))
 446         continue;
 447
 448       /* take care of the special icodes first */
 449       if (ic->op == JUMPTABLE && IS_SYMOP (IC_JTCOND (ic)))
 450         {
 451           operandLUse (IC_JTCOND (ic), ebbs, count, ic, ebp);
 452           continue;
 453         }
 454
 455       if (ic->op == IFX && IS_SYMOP (IC_COND (ic)))
 456         {
 457           operandLUse (IC_COND (ic), ebbs, count, ic, ebp);
 458           continue;
 459         }
 460
 461       if (IS_SYMOP (IC_LEFT (ic)))
 462         operandLUse (IC_LEFT (ic), ebbs, count, ic, ebp);
 463
 464       if (IS_SYMOP (IC_RIGHT (ic)))
 465         operandLUse (IC_RIGHT (ic), ebbs, count, ic, ebp);
 466
 467       if (POINTER_SET (ic))
 468         operandLUse (IC_RESULT (ic), ebbs, count, ic, ebp);
 469       else if (IC_RESULT (ic))
 470         ic->defKey = IC_RESULT (ic)->key;
 471     }
 472
 473
 474   /* for all the definitions in the block */
 475   /* compute and set the live from        */
 476   if (ebp->ldefs && !bitVectIsZero (ebp->ldefs))
 477     {
 478       for (i = 0; i < ebp->ldefs->size; i++)
 479         {
 480           iCode *dic;
 481
 482           if (bitVectBitValue (ebp->ldefs, i) &&
 483               (dic = hTabItemWithKey (iCodehTab, i)))
 484             {
 485
 486               /* if the definition has a from & it is greater */
 487               /* than the defininng iCode->seq then change it */
 488               setFromRange (IC_RESULT (dic), dic->seq);
 489             }
 490         }
 491     }
 492
 493   /* special case for lastBlock in a loop: here we
 494      mark the end of all the induction variables for the
 495      loop */
 496   if (ebp->isLastInLoop && !bitVectIsZero (ebp->linds))
 497     {
 498       for (i = 0; i <= ebp->linds->size; i++)
 499         {
 500           iCode *dic;
 501
 502           if (bitVectBitValue (ebp->linds, i) &&
 503               (dic = hTabItemWithKey (iCodehTab, i)))
 504             {
 505
 506               /* if this is a register equvalent make sure
 507                  it is not defined or used anywhere after the loop */
 508               if (OP_SYMBOL (IC_RESULT (dic))->isreqv &&
 509                   defUsedAfterLoop (IC_RESULT (dic), ebp->lSeq))
 510                 continue;
 511
 512               setToRange (IC_RESULT (dic), (ebp->lSeq), FALSE);
 513             }
 514         }
 515     }
 516
 517   /* for defnitions coming into the block if they */
 518   /* not used by itself & any of its successors   */
 519   /* they are dead */
 520   /* first union the definitions used in all successors
 521      and itself */
 522   for (i = 0; i < count; ebbs[i++]->visited = 0);
 523   applyToSet (ebp->succList, unionDefsUsed, &defsUsed);
 524   defsUsed = bitVectUnion (defsUsed, ebp->usesDefs);
 525
 526   /* now subract the result of these unions from */
 527   /* the incoming definitions this will give the */
 528   /* definitions that are never used in the future */
 529   defsNotUsed = bitVectCplAnd (bitVectCopy (ebp->inDefs),
 530                                defsUsed);
 531
 532   /* mark the end of the defintions */
 533   if (!bitVectIsZero (defsNotUsed) && ebp->sch)
 534     {
 535       for (i = 0; i < defsNotUsed->size; i++)
 536         {
 537           iCode *dic;
 538
 539           if (bitVectBitValue (defsNotUsed, i) &&
 540               (dic = hTabItemWithKey (iCodehTab, i)))
 541             {
 542
 543               setToRange (IC_RESULT (dic), (ebp->fSeq - 1), TRUE);
 544             }
 545         }
 546     }
 547
 548
 549   /* if we reach a lock with noPath to it then kill all
 550      the live ranges alive at this point */
 551 /*     if (ebp->noPath || ebp->entryLabel == returnLabel) */
 552   if (ebp->entryLabel == returnLabel)
 553     killAllAlive (ebp->fSeq);
 554 }
 555
 556 /*-----------------------------------------------------------------*/
 557 /* rlivePoint - for each point compute the ranges that are alive   */
 558 /*-----------------------------------------------------------------*/
 559 void
 560 rlivePoint (eBBlock ** ebbs, int count)
 561 {
 562     int i;
 563
 564     /* for all blocks do */
 565     for (i = 0; i < count; i++) {
 566         iCode *ic;
 567
 568         /* for all instruction in the block do */
 569         for (ic = ebbs[i]->sch; ic; ic = ic->next) {
 570             symbol *lrange;
 571             int k;
 572
 573             ic->rlive = newBitVect (operandKey);
 574             /* for all symbols in the liverange table */
 575             for (lrange = hTabFirstItem (liveRanges, &k); lrange;
 576                  lrange = hTabNextItem (liveRanges, &k)) {
 577
 578                 /* if it is live then add the lrange to ic->rlive */
 579                 if (lrange->liveFrom <= ic->seq &&
 580                     lrange->liveTo >= ic->seq) {
 581                     lrange->isLiveFcall |= (ic->op == CALL || ic->op == PCALL || ic->op == SEND);
 582                     ic->rlive = bitVectSetBit (ic->rlive, lrange->key);
 583                 }
 584             }
 585 #if 0
 586             /* overlapping live ranges should be eliminated */
 587             if (ASSIGN_ITEMP_TO_ITEMP (ic)) {
 588                 if (SPIL_LOC(IC_RIGHT(ic)) == SPIL_LOC(IC_RESULT(ic))   && /* left & right share the same spil location */
 589                     OP_SYMBOL(IC_RESULT(ic))->isreqv                    && /* left of assign is a register requivalent */
 590                     !OP_SYMBOL(IC_RIGHT(ic))->isreqv                    && /* right side is not */
 591                     OP_SYMBOL(IC_RIGHT(ic))->liveTo > ic->key           && /* right side live beyond this point */
 592                     bitVectnBitsOn(OP_DEFS(IC_RESULT(ic))) > 1 )        {  /* left has multiple definitions */
 593                     SPIL_LOC(IC_RIGHT(ic)) = NULL; /* then cannot share */
 594                 }
 595             }
 596 #endif
 597         }
 598     }
 599 }
 600
 601 /*-----------------------------------------------------------------*/
 602 /* computeClash - find out which live ranges collide with others   */
 603 /*-----------------------------------------------------------------*/
 604 static void computeClash ()
 605 {
 606     hTab *lRangeCopy = newHashTable(hTabMaxKey(liveRanges));
 607     void *item;
 608     symbol *outer, *inner;
 609     int key, key1;
 610
 611     /* have to make a copy of the liveRanges hashTable :: UGHH .*/
 612     for (item = hTabFirstItem(liveRanges,&key); item ;
 613          item = hTabNextItem(liveRanges,&key)) {
 614         hTabAddItem(&lRangeCopy,key,item);
 615     }
 616
 617     /* outerloop : for each liverange do */
 618     for (outer = hTabFirstItem(liveRanges,&key); outer ;
 619          outer = hTabNextItem(liveRanges,&key)) {
 620
 621         /* if the liveFrom & To are the same then skip,
 622            could happen for unused return values from functions */
 623         if (outer->liveFrom == outer->liveTo) continue;
 624
 625         /* innerloop : for the inner loop we can start from the
 626            item after the outer loop */
 627         inner = hTabFirstItemWK (lRangeCopy,outer->key);
 628         inner = hTabNextItem (lRangeCopy,&key1 );
 629         for (; inner ; inner = hTabNextItem( lRangeCopy ,&key1)) {
 630
 631             if (inner->liveFrom == inner->liveTo) continue;
 632             if (inner->liveTo < outer->liveFrom)  continue;
 633             if (inner->liveFrom > outer->liveTo)  continue;
 634
 635             /* if one of them are being defined where the other
 636                one end , then no overlap (i.e. they can goto same registers */
 637             if (inner->liveFrom == outer->liveTo ||
 638                 outer->liveFrom == inner->liveTo) continue;
 639
 640             /* so they overlap : set both their clashes */
 641             inner->clashes = bitVectSetBit(inner->clashes,outer->key);
 642             outer->clashes = bitVectSetBit(outer->clashes,inner->key);
 643
 644             /* check if they share the same spillocation */
 645             if (SYM_SPIL_LOC(inner) && SYM_SPIL_LOC(outer) &&
 646                 SYM_SPIL_LOC(inner) == SYM_SPIL_LOC(outer)) {
 647                 if (inner->reqv && !outer->reqv) SYM_SPIL_LOC(outer)=NULL;
 648                 else if (outer->reqv && !inner->reqv) SYM_SPIL_LOC(inner)=NULL;
 649                 else if (inner->used > outer->used) SYM_SPIL_LOC(outer)=NULL;
 650                 else SYM_SPIL_LOC(inner)=NULL;
 651             }
 652
 653         }
 654     }
 655 }
 656
 657 /*-----------------------------------------------------------------*/
 658 /* computeLiveRanges - computes the live ranges for variables      */
 659 /*-----------------------------------------------------------------*/
 660 void
 661 computeLiveRanges (eBBlock ** ebbs, int count)
 662 {
 663   int i = 0;
 664   /* sequence the code the live ranges are computed
 665      in terms of this sequence additionally the
 666      routine will also create a hashtable of instructions */
 667   iCodeSeq = 0;
 668   setToNull ((void **) &iCodehTab);
 669   iCodehTab = newHashTable (iCodeKey);
 670   setToNull ((void **) &iCodeSeqhTab);
 671   iCodeSeqhTab = newHashTable (iCodeKey);
 672   sequenceiCode (ebbs, count);
 673
 674   /* call routine to mark the from & to live ranges for
 675      variables used */
 676   setToNull ((void **) &liveRanges);
 677   for (i = 0; i < count; i++)
 678     markLiveRanges (ebbs[i], ebbs, count);
 679
 680   /* mark the ranges live for each point */
 681   rlivePoint (ebbs, count);
 682
 683   /* compute which overlaps with what */
 684   computeClash();
 685 }