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