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