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

   1 /*-------------------------------------------------------------------------
   2
   3    pcoderegs.c - post code generation register optimizations
   4
   5    Written By -  Scott Dattalo scott@dattalo.com
   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 -------------------------------------------------------------------------*/
  22
  23 /*
  24   pcoderegs.c
  25
  26   The purpose of the code in this file is to optimize the register usage.
  27
  28 */
  29 #include <stdio.h>
  30
  31 #include "common.h"   // Include everything in the SDCC src directory
  32 #include "newalloc.h"
  33 #include "ralloc.h"
  34 #include "device.h"
  35 #include "pcode.h"
  36 #include "pcoderegs.h"
  37 #include "pcodeflow.h"
  38
  39 extern void pCodeInsertAfter(pCode *pc1, pCode *pc2);
  40 extern void dbg_dumpregusage(void);
  41 extern pCode * findPrevInstruction(pCode *pci);
  42 extern pBranch * pBranchAppend(pBranch *h, pBranch *n);
  43 void unlinkpCode(pCode *pc);
  44
  45 int total_registers_saved=0;
  46
  47 /*-----------------------------------------------------------------*
  48  * void AddRegToFlow(regs *reg, pCodeFlow *pcfl)
  49  *-----------------------------------------------------------------*/
  50 /*
  51 void AddRegToFlow(regs *reg, pCodeFlow *pcfl)
  52 {
  53
  54   if(!reg || ! pcfl || !isPCFL(pcflow))
  55     return;
  56
  57   if(!pcfl->registers)
  58     pcfl->registers =  newSet();
  59
  60 }
  61 */
  62
  63
  64 /*-----------------------------------------------------------------*
  65  *
  66  *-----------------------------------------------------------------*/
  67 void dbg_regusage(set *fregs)
  68 {
  69   regs *reg;
  70   pCode *pcfl;
  71   pCode *pc;
  72
  73
  74   for (reg = setFirstItem(fregs) ; reg ;
  75        reg = setNextItem(fregs)) {
  76
  77     if(elementsInSet(reg->reglives.usedpCodes)) {
  78
  79       fprintf (stderr, "%s  addr=0x%03x rIdx=0x%03x",
  80                reg->name,
  81                reg->address,
  82                reg->rIdx);
  83
  84       pcfl = setFirstItem(reg->reglives.usedpFlows);
  85       if(pcfl)
  86         fprintf(stderr, "\n   used in seq");
  87
  88       while(pcfl) {
  89         fprintf(stderr," 0x%03x",pcfl->seq);
  90         pcfl = setNextItem(reg->reglives.usedpFlows);
  91       }
  92
  93       pcfl = setFirstItem(reg->reglives.assignedpFlows);
  94       if(pcfl)
  95         fprintf(stderr, "\n   assigned in seq");
  96
  97       while(pcfl) {
  98         fprintf(stderr," 0x%03x",pcfl->seq);
  99         pcfl = setNextItem(reg->reglives.assignedpFlows);
 100       }
 101
 102       pc = setFirstItem(reg->reglives.usedpCodes);
 103       if(pc)
 104         fprintf(stderr, "\n   used in instructions ");
 105
 106       while(pc) {
 107         pcfl = PCODE(PCI(pc)->pcflow);
 108         if(pcfl)
 109           fprintf(stderr," 0x%03x:",pcfl->seq);
 110         fprintf(stderr,"0x%03x",pc->seq);
 111
 112         pc = setNextItem(reg->reglives.usedpCodes);
 113       }
 114
 115       fprintf(stderr, "\n");
 116     }
 117   }
 118 }
 119
 120 /*-----------------------------------------------------------------*
 121  *
 122  *-----------------------------------------------------------------*/
 123 void dbg_dumpregusage(void)
 124 {
 125
 126   fprintf(stderr,"***  Register Usage  ***\n");
 127   fprintf(stderr,"InternalRegs:\n");
 128   dbg_regusage(dynInternalRegs);
 129   fprintf(stderr,"AllocRegs:\n");
 130   dbg_regusage(dynAllocRegs);
 131   fprintf(stderr,"StackRegs:\n");
 132   dbg_regusage(dynStackRegs);
 133   fprintf(stderr,"DirectRegs:\n");
 134   dbg_regusage(dynDirectRegs);
 135   fprintf(stderr,"DirectBitRegs:\n");
 136   dbg_regusage(dynDirectBitRegs);
 137   fprintf(stderr,"ProcessorRegs:\n");
 138   dbg_regusage(dynProcessorRegs);
 139
 140 }
 141
 142
 143 /*-----------------------------------------------------------------*
 144  * void pCodeRegMapLiveRangesInFlow(pCodeFlow *pcfl)
 145  *-----------------------------------------------------------------*/
 146 void pCodeRegMapLiveRangesInFlow(pCodeFlow *pcfl)
 147 {
 148
 149   pCode *pc=NULL;
 150   pCode *pcprev=NULL;
 151
 152   regs *reg;
 153
 154   if(!pcfl)
 155     return;
 156
 157
 158   pc = findNextInstruction(pcfl->pc.next);
 159
 160   while(isPCinFlow(pc,PCODE(pcfl))) {
 161
 162
 163     reg = getRegFromInstruction(pc);
 164
 165     if(reg) {
 166 /*
 167       fprintf(stderr, "flow seq %d, inst seq %d  %s  ",PCODE(pcfl)->seq,pc->seq,reg->name);
 168       fprintf(stderr, "addr = 0x%03x, type = %d  rIdx=0x%03x\n",
 169               reg->address,reg->type,reg->rIdx);
 170 */
 171
 172       addSetIfnotP(& (PCFL(pcfl)->registers), reg);
 173
 174       if((PCC_REGISTER | PCC_LITERAL) & PCI(pc)->inCond)
 175         addSetIfnotP(& (reg->reglives.usedpFlows), pcfl);
 176
 177       if(PCC_REGISTER & PCI(pc)->outCond)
 178         addSetIfnotP(& (reg->reglives.assignedpFlows), pcfl);
 179
 180       addSetIfnotP(& (reg->reglives.usedpCodes), pc);
 181     }
 182
 183
 184     pcprev = pc;
 185     pc = findNextInstruction(pc->next);
 186
 187   }
 188
 189 }
 190
 191 /*-----------------------------------------------------------------*
 192  * void pCodeRegMapLiveRanges(pBlock *pb)
 193  *-----------------------------------------------------------------*/
 194 void pCodeRegMapLiveRanges(pBlock *pb)
 195 {
 196   pCode *pcflow;
 197
 198   for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
 199        pcflow != NULL;
 200        pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
 201
 202     if(!isPCFL(pcflow)) {
 203       fprintf(stderr, "pCodeRegMapLiveRanges - pcflow is not a flow object ");
 204       continue;
 205     }
 206     pCodeRegMapLiveRangesInFlow(PCFL(pcflow));
 207   }
 208
 209 #if 0
 210   for( pcflow = findNextpCode(pb->pcHead, PC_FLOW);
 211        pcflow != NULL;
 212        pcflow = findNextpCode(pcflow->next, PC_FLOW) ) {
 213
 214     regs *r = setFirstItem(PCFL(pcflow)->registers);
 215     fprintf(stderr,"flow seq %d\n", pcflow->seq);
 216
 217     while (r) {
 218       fprintf(stderr, "  %s\n",r->name);
 219       r = setNextItem(PCFL(pcflow)->registers);
 220
 221     }
 222
 223   }
 224 #endif
 225
 226 //  dbg_dumpregusage();
 227
 228 }
 229
 230
 231 /*-----------------------------------------------------------------*
 232  *
 233  *-----------------------------------------------------------------*/
 234 static void Remove1pcode(pCode *pc, regs *reg)
 235 {
 236   pCode *pcn=NULL;
 237
 238   if(!reg || !pc)
 239     return;
 240
 241   deleteSetItem (&(reg->reglives.usedpCodes),pc);
 242 /*
 243   fprintf(stderr,"removing instruction:\n");
 244   pc->print(stderr,pc);
 245 */
 246   if(PCI(pc)->label) {
 247     pcn = findNextInstruction(pc->next);
 248
 249     if(pcn)
 250       PCI(pcn)->label = pBranchAppend(PCI(pcn)->label,PCI(pc)->label);
 251   }
 252
 253   if(PCI(pc)->cline) {
 254     if(!pcn)
 255       pcn = findNextInstruction(pc->next);
 256
 257     if(pcn) {
 258       if(PCI(pcn)->cline) {
 259         //fprintf(stderr, "source line has been optimized completely out\n");
 260         //pc->print(stderr,pc);
 261       } else {
 262         PCI(pcn)->cline = PCI(pc)->cline;
 263       }
 264     }
 265   }
 266
 267   pc->destruct(pc);
 268
 269 }
 270
 271 /*-----------------------------------------------------------------*
 272  * void RemoveRegsFromSet(set *regset)
 273  *
 274  *-----------------------------------------------------------------*/
 275 void  RemoveRegsFromSet(set *regset)
 276 {
 277   regs *reg;
 278   int used;
 279
 280   while(regset) {
 281     reg = regset->item;
 282     regset = regset->next;
 283
 284     used = elementsInSet(reg->reglives.usedpCodes);
 285
 286     if(used <= 1) {
 287
 288       //fprintf(stderr," reg %s isfree=%d, wasused=%d\n",reg->name,reg->isFree,reg->wasUsed);
 289       if(used == 0) {
 290         //fprintf(stderr," getting rid of reg %s\n",reg->name);
 291         reg->isFree = 1;
 292         reg->wasUsed = 0;
 293       } else {
 294         pCode *pc;
 295
 296
 297         pc = setFirstItem(reg->reglives.usedpCodes);
 298
 299         if(reg->type == REG_SFR) {
 300           //fprintf(stderr, "not removing SFR reg %s even though used only once\n",reg->name);
 301           continue;
 302         }
 303
 304
 305         if(isPCI(pc)) {
 306           if(PCI(pc)->label) {
 307             pCode *pcn = findNextInstruction(pc->next);
 308
 309             if(pcn && PCI(pcn)->label) {
 310               //fprintf(stderr,"can't delete instruction with label...\n");
 311               //pc->print(stderr,pc);
 312               continue;
 313             }
 314             /* Move the label to the next instruction */
 315
 316             PCI(pcn)->label = PCI(pc)->label;
 317
 318           }
 319
 320           if(isPCI_SKIP(pc)) {
 321             regs *r = getRegFromInstruction(pc);
 322             fprintf(stderr, "WARNING, a skip instruction is being optimized out\n");
 323             pc->print(stderr,pc);
 324             fprintf(stderr,"reg %s, type =%d\n",r->name, r->type);
 325           }
 326           //fprintf(stderr," removing reg %s because it is used only once\n",reg->name);
 327           Remove1pcode(pc, reg);
 328           /*
 329             unlinkpCode(pc);
 330             deleteSetItem (&(reg->reglives.usedpCodes),pc);
 331           */
 332           reg->isFree = 1;
 333           reg->wasUsed = 0;
 334           total_registers_saved++;  // debugging stats.
 335         }
 336       }
 337     }
 338
 339   }
 340 }
 341 /*-----------------------------------------------------------------*
 342  * void RemoveUnusedRegisters(void)
 343  *
 344  *-----------------------------------------------------------------*/
 345 void RemoveUnusedRegisters(void)
 346 {
 347   /* First, get rid of registers that are used only one time */
 348
 349   RemoveRegsFromSet(dynInternalRegs);
 350   RemoveRegsFromSet(dynAllocRegs);
 351   RemoveRegsFromSet(dynStackRegs);
 352   /*
 353     don't do DirectRegs yet - there's a problem with arrays
 354   RemoveRegsFromSet(dynDirectRegs);
 355   */
 356   RemoveRegsFromSet(dynDirectBitRegs);
 357
 358   if(total_registers_saved) fprintf(stderr, " *** Saved %d registers ***\n", total_registers_saved);
 359 }
 360
 361
 362 /*-----------------------------------------------------------------*
 363  *
 364  *-----------------------------------------------------------------*/
 365 static void Remove2pcodes(pCode *pcflow, pCode *pc1, pCode *pc2, regs *reg, int can_free)
 366 {
 367   if(!reg)
 368     return;
 369
 370   if(pc1)
 371     Remove1pcode(pc1, reg);
 372
 373   if(pc2) {
 374     Remove1pcode(pc2, reg);
 375     deleteSetItem (&(PCFL(pcflow)->registers), reg);
 376
 377     if(can_free) {
 378       reg->isFree = 1;
 379       reg->wasUsed = 0;
 380     }
 381
 382   }
 383
 384   pCodeRegMapLiveRangesInFlow(PCFL(pcflow));
 385 }
 386
 387 /*-----------------------------------------------------------------*
 388  *
 389  *-----------------------------------------------------------------*/
 390 int regUsedinRange(pCode *pc1, pCode *pc2, regs *reg)
 391 {
 392   int i=0;
 393   regs *testreg;
 394
 395   do {
 396     testreg = getRegFromInstruction(pc1);
 397     if(testreg && (testreg->rIdx == reg->rIdx)) {
 398       return 1;
 399     }
 400
 401     pc1 = findNextInstruction(pc1->next);
 402
 403   } while (pc1 && (pc1 != pc2) && (i++ < 100)) ;
 404
 405   if(i >= 100)
 406     fprintf(stderr, "warning, regUsedinRange searched through too many pcodes\n");
 407
 408   return 0;
 409 }
 410
 411 /*-----------------------------------------------------------------*
 412  * void pCodeOptime2pCodes(pCode *pc1, pCode *pc2)
 413  *
 414  * ADHOC pattern checking
 415  * Now look for specific sequences that are easy to optimize.
 416  * Many of these sequences are characteristic of the compiler
 417  * (i.e. it'd probably be a waste of time to apply these adhoc
 418  * checks to hand written assembly.)
 419  *
 420  *
 421  *-----------------------------------------------------------------*/
 422 int pCodeOptime2pCodes(pCode *pc1, pCode *pc2, pCode *pcfl_used, regs *reg, int can_free)
 423 {
 424   pCode *pct1, *pct2;
 425   regs  *reg1, *reg2;
 426
 427   int t = total_registers_saved;
 428
 429   if(pc2->seq < pc1->seq) {
 430     pct1 = pc2;
 431     pc2 = pc1;
 432     pc1 = pct1;
 433   }
 434
 435
 436   if((PCI(pc1)->op == POC_CLRF) && (PCI(pc2)->op == POC_MOVFW) ){
 437
 438     /*
 439       clrf  reg
 440       stuff...
 441       movf  reg,w
 442
 443       can be replaced with
 444
 445       stuff...
 446       movlw 0
 447     */
 448
 449     pCode *newpc;
 450     //fprintf(stderr, "   CLRF/MOVFW. instruction after MOVFW is:\n");
 451     pct1 = findNextInstruction(pc2->next);
 452     //t->print(stderr,t);
 453
 454     if(PCI(pct1)->op == POC_MOVWF) {
 455       newpc = newpCode(POC_CLRF, PCI(pct1)->pcop);
 456       pct1->destruct(pct1);
 457     } else {
 458       newpc = newpCode(POC_MOVLW, newpCodeOpLit(0));
 459     }
 460
 461     pCodeInsertAfter(pc2, newpc);
 462     PCI(newpc)->pcflow = PCFL(pcfl_used);
 463     newpc->seq = pc2->seq;
 464
 465     Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
 466     total_registers_saved++;  // debugging stats.
 467
 468   } else if((PCI(pc1)->op == POC_CLRF) && (PCI(pc2)->op == POC_IORFW) ){
 469     //fprintf(stderr, "   CLRF/IORFW.\n");
 470
 471     Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
 472     total_registers_saved++;  // debugging stats.
 473
 474   }  else if(PCI(pc1)->op == POC_MOVWF) {
 475
 476     pct2 = findNextInstruction(pc2->next);
 477
 478     if(PCI(pc2)->op == POC_MOVFW) {
 479       //fprintf(stderr, "   MOVWF/MOVFW. instruction after MOVFW is:\n");
 480       //pct2->print(stderr,pct2);
 481
 482       if(PCI(pct2)->op == POC_MOVWF) {
 483         reg2 = getRegFromInstruction(pct2);
 484         if(reg2 && !regUsedinRange(pc1,pc2,reg2) && (reg2->type != REG_SFR)) {
 485           pct2->seq = pc1->seq;
 486           unlinkpCode(pct2);
 487           pCodeInsertAfter(pc1,pct2);
 488           Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
 489           total_registers_saved++;  // debugging stats.
 490           return 1;
 491         }
 492 /*
 493         fprintf(stderr, " couldn't optimize\n");
 494         if(reg2)
 495           fprintf(stderr, " %s is used in range\n",reg2->name);
 496         else
 497           fprintf(stderr, " reg2 is NULL\n");
 498 */
 499       }
 500     }
 501
 502     pct1 = findPrevInstruction(pc1->prev);
 503     if(pct1 &&
 504        (PCI(pct1)->pcflow == PCI(pc1)->pcflow) &&
 505        (PCI(pct1)->op == POC_MOVFW)) {
 506
 507       reg1 = getRegFromInstruction(pct1);
 508       if(reg1 && !regUsedinRange(pc1,pc2,reg1)) {
 509         //fprintf(stderr, "   MOVF/MOVFW. \n");
 510         /*
 511           movf   reg1,w
 512           movwf  reg
 513
 514           stuff...
 515           opcode reg,w
 516         */
 517         pct2 = newpCode(PCI(pc2)->op, PCI(pct1)->pcop);
 518         pCodeInsertAfter(pc2, pct2);
 519         PCI(pct2)->pcflow = PCFL(pcfl_used);
 520         pct2->seq = pc2->seq;
 521
 522         Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
 523         Remove2pcodes(pcfl_used, pct1, NULL, reg1, 0);
 524         total_registers_saved++;  // debugging stats.
 525
 526       }
 527     }
 528
 529
 530   }
 531
 532   return (total_registers_saved != t);
 533 }
 534
 535 /*-----------------------------------------------------------------*
 536  * void pCodeRegOptimeRegUsage(pBlock *pb)
 537  *-----------------------------------------------------------------*/
 538 void OptimizeRegUsage(set *fregs, int optimize_multi_uses)
 539 {
 540   regs *reg;
 541   int used;
 542   pCode *pc1=NULL, *pc2=NULL;
 543
 544
 545   while(fregs) {
 546     pCode *pcfl_used, *pcfl_assigned;
 547
 548     /* Step through the set by directly accessing the 'next' pointer.
 549      * We could also step through by using the set API, but the
 550      * the (debug) calls to print instructions affect the state
 551      * of the set pointers */
 552
 553     reg = fregs->item;
 554     fregs = fregs->next;
 555
 556     if(reg->type == REG_SFR) {
 557       //fprintf(stderr,"skipping SFR: %s\n",reg->name);
 558       continue;
 559     }
 560
 561     pcfl_used = setFirstItem(reg->reglives.usedpFlows);
 562     pcfl_assigned = setFirstItem(reg->reglives.assignedpFlows);
 563
 564     used = elementsInSet(reg->reglives.usedpCodes);
 565     if(used == 2) {
 566
 567       /*
 568        * In this section, all registers that are used in only in two
 569        * instructions are examined. If possible, they're optimized out.
 570        */
 571
 572 /*
 573       fprintf (stderr, "OptimizeRegUsage: %s  addr=0x%03x rIdx=0x%03x type=%d used=%d\n",
 574                reg->name,
 575                reg->address,
 576                reg->rIdx, reg->type, used);
 577 */
 578       pc1 = setFirstItem(reg->reglives.usedpCodes);
 579       pc2 = setNextItem(reg->reglives.usedpCodes);
 580
 581       if(pcfl_used && pcfl_assigned) {
 582
 583         /*
 584            expected case - the register has been assigned a value and is
 585            subsequently used
 586         */
 587
 588         //fprintf(stderr," used only twice\n");
 589         if(pcfl_used->seq == pcfl_assigned->seq) {
 590
 591           //fprintf(stderr, "  and used in same flow\n");
 592
 593           pCodeOptime2pCodes(pc1, pc2, pcfl_used, reg, 1);
 594
 595         } else {
 596           // fprintf(stderr, "  and used in different flows\n");
 597
 598         }
 599
 600       } else if(pcfl_used) {
 601
 602         /*
 603           register has been used twice without ever being assigned */
 604         //fprintf(stderr,"WARNING %s: reg %s used without being assigned\n",__FUNCTION__,reg->name);
 605
 606       } else {
 607         //fprintf(stderr,"WARNING %s: reg %s assigned without being used\n",__FUNCTION__,reg->name);
 608         Remove2pcodes(pcfl_assigned, pc1, pc2, reg, 1);
 609         total_registers_saved++;  // debugging stats.
 610       }
 611     } else {
 612
 613       /* register has been used either once, or more than twice */
 614
 615       if(used && !pcfl_used && pcfl_assigned) {
 616         pCode *pc;
 617
 618         //fprintf(stderr,"WARNING %s: reg %s assigned without being used\n",__FUNCTION__,reg->name);
 619
 620         pc = setFirstItem(reg->reglives.usedpCodes);
 621         while(pc) {
 622
 623           pcfl_assigned = PCODE(PCI(pc)->pcflow);
 624           Remove1pcode(pc, reg);
 625
 626           deleteSetItem (&(PCFL(pcfl_assigned)->registers), reg);
 627           /*
 628           deleteSetItem (&(reg->reglives.usedpCodes),pc);
 629           pc->destruct(pc);
 630           */
 631           pc = setNextItem(reg->reglives.usedpCodes);
 632         }
 633
 634
 635         reg->isFree = 1;
 636         reg->wasUsed = 0;
 637
 638         total_registers_saved++;  // debugging stats.
 639       } else if( (used > 2) && optimize_multi_uses) {
 640
 641         set *rset1=NULL;
 642         set *rset2=NULL;
 643         int searching=1;
 644
 645         pCodeFlow *pcfl1=NULL, *pcfl2=NULL;
 646
 647         /* examine the number of times this register is used */
 648
 649
 650         rset1 = reg->reglives.usedpCodes;
 651         while(rset1 && searching) {
 652
 653           pc1 = rset1->item;
 654           rset2 = rset1->next;
 655
 656           if(pc1 && isPCI(pc1) &&  ( (pcfl1 = PCI(pc1)->pcflow) != NULL) ) {
 657
 658             while(rset2 && searching) {
 659
 660               pc2 = rset2->item;
 661               if(pc2 && isPCI(pc2)  &&  ( (pcfl2 = PCI(pc2)->pcflow) != NULL) )  {
 662                 if(pcfl2 == pcfl1) {
 663 /*
 664                   fprintf(stderr, " two instruction in same flow\n");
 665                   pc1->print(stderr, pc1);
 666                   pc2->print(stderr, pc2);
 667 */
 668                   //if(pCodeOptime2pCodes(pc1, pc2, pcfl_used, reg, 1))
 669                   //  searching = 0;
 670                 }
 671               }
 672
 673               rset2 = rset2->next;
 674
 675             }
 676           }
 677           rset1 = rset1->next;
 678         }
 679       }
 680     }
 681
 682   }
 683
 684 }
 685 /*-----------------------------------------------------------------*
 686  * void pCodeRegOptimeRegUsage(pBlock *pb)
 687  *-----------------------------------------------------------------*/
 688 void pCodeRegOptimizeRegUsage(void)
 689 {
 690
 691   int passes;
 692   int saved = 0;
 693   int t = total_registers_saved;
 694   int optimize_multi = 0;
 695
 696   do {
 697     passes = 4;
 698
 699     //fprintf(stderr, " multi opti %d\n",optimize_multi);
 700
 701     do {
 702       saved = total_registers_saved;
 703
 704       /* Identify registers used in one flow sequence */
 705       OptimizeRegUsage(dynAllocRegs,optimize_multi);
 706       OptimizeRegUsage(dynStackRegs,0);
 707       OptimizeRegUsage(dynDirectRegs,0);
 708
 709       if(total_registers_saved != saved)
 710         fprintf(stderr, " *** Saved %d registers, total saved %d ***\n", total_registers_saved-saved,total_registers_saved);
 711
 712
 713     } while( passes-- && (total_registers_saved != saved));
 714
 715     optimize_multi++;
 716   } while (optimize_multi < 2);
 717
 718   if(total_registers_saved == t)
 719     fprintf(stderr, "No registers saved on this pass\n");
 720
 721
 722 /*
 723   fprintf(stderr,"dynamically allocated regs:\n");
 724   dbg_regusage(dynAllocRegs);
 725   fprintf(stderr,"stack regs:\n");
 726   dbg_regusage(dynStackRegs);
 727   fprintf(stderr,"direct regs:\n");
 728   dbg_regusage(dynDirectRegs);
 729 */
 730 }
 731
 732
 733 /*-----------------------------------------------------------------*
 734  * void RegsUnMapLiveRanges(set *regset)
 735  *
 736  *-----------------------------------------------------------------*/
 737 void  RegsSetUnMapLiveRanges(set *regset)
 738 {
 739   regs *reg;
 740
 741   while(regset) {
 742     reg = regset->item;
 743     regset = regset->next;
 744
 745
 746     deleteSet(&reg->reglives.usedpCodes);
 747     deleteSet(&reg->reglives.usedpFlows);
 748     deleteSet(&reg->reglives.assignedpFlows);
 749
 750   }
 751
 752 }
 753
 754 void  RegsUnMapLiveRanges(void)
 755 {
 756
 757   RegsSetUnMapLiveRanges(dynAllocRegs);
 758   RegsSetUnMapLiveRanges(dynStackRegs);
 759   RegsSetUnMapLiveRanges(dynDirectRegs);
 760   RegsSetUnMapLiveRanges(dynProcessorRegs);
 761   RegsSetUnMapLiveRanges(dynDirectBitRegs);
 762   RegsSetUnMapLiveRanges(dynInternalRegs);
 763
 764 }