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

   1 /*-------------------------------------------------------------------------
   2
   3   pcoderegs.c - post code generation register optimizations
   4
   5    Written By -  Scott Dattalo scott@dattalo.com
   6    Ported To PIC16 By -  m.dubuc@rogers.com
   7
   8    This program is free software; you can redistribute it and/or modify it
   9    under the terms of the GNU General Public License as published by the
  10    Free Software Foundation; either version 2, or (at your option) any
  11    later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  21
  22 -------------------------------------------------------------------------*/
  23
  24 /*
  25   pcoderegs.c
  26
  27   The purpose of the code in this file is to optimize the register usage.
  28
  29 */
  30 #include <stdio.h>
  31
  32 #include "common.h"   // Include everything in the SDCC src directory
  33 #include "newalloc.h"
  34 #include "ralloc.h"
  35 #include "device.h"
  36 #include "pcode.h"
  37 #include "pcoderegs.h"
  38 #include "pcodeflow.h"
  39
  40 extern void pic16_pCodeInsertAfter(pCode *pc1, pCode *pc2);
  41 extern pCode * pic16_findPrevInstruction(pCode *pci);
  42 extern pBranch * pic16_pBranchAppend(pBranch *h, pBranch *n);
  43 void pic16_unlinkpCode(pCode *pc);
  44 extern int pic16_pCodeSearchCondition(pCode *pc, unsigned int cond);
  45
  46 static int total_registers_saved=0;
  47 static 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 #if 0
  70 static void dbg_regusage(set *fregs)
  71 {
  72   regs *reg;
  73   pCode *pcfl;
  74   pCode *pc;
  75
  76
  77   for (reg = setFirstItem(fregs) ; reg ;
  78        reg = setNextItem(fregs)) {
  79
  80     if(elementsInSet(reg->reglives.usedpCodes)) {
  81
  82       fprintf (stderr, "%s  addr=0x%03x rIdx=0x%03x",
  83                reg->name,
  84                reg->address,
  85                reg->rIdx);
  86
  87       pcfl = setFirstItem(reg->reglives.usedpFlows);
  88       if(pcfl)
  89         fprintf(stderr, "\n   used in seq");
  90
  91       while(pcfl) {
  92         fprintf(stderr," 0x%03x",pcfl->seq);
  93         pcfl = setNextItem(reg->reglives.usedpFlows);
  94       }
  95
  96       pcfl = setFirstItem(reg->reglives.assignedpFlows);
  97       if(pcfl)
  98         fprintf(stderr, "\n   assigned in seq");
  99
 100       while(pcfl) {
 101         fprintf(stderr," 0x%03x",pcfl->seq);
 102         pcfl = setNextItem(reg->reglives.assignedpFlows);
 103       }
 104
 105       pc = setFirstItem(reg->reglives.usedpCodes);
 106       if(pc)
 107         fprintf(stderr, "\n   used in instructions ");
 108
 109       while(pc) {
 110         pcfl = PCODE(PCI(pc)->pcflow);
 111         if(pcfl)
 112           fprintf(stderr," 0x%03x:",pcfl->seq);
 113         fprintf(stderr,"0x%03x",pc->seq);
 114
 115         pc = setNextItem(reg->reglives.usedpCodes);
 116       }
 117
 118       fprintf(stderr, "\n");
 119     }
 120   }
 121 }
 122 #endif
 123
 124 /*-----------------------------------------------------------------*
 125  *
 126  *-----------------------------------------------------------------*/
 127 #if 0
 128 static void dbg_dumpregusage(void)
 129 {
 130
 131   fprintf(stderr,"***  Register Usage  ***\n");
 132   fprintf(stderr,"InternalRegs:\n");
 133   dbg_regusage(pic16_dynInternalRegs);
 134   fprintf(stderr,"AllocRegs:\n");
 135   dbg_regusage(pic16_dynAllocRegs);
 136   fprintf(stderr,"StackRegs:\n");
 137   dbg_regusage(pic16_dynStackRegs);
 138   fprintf(stderr,"DirectRegs:\n");
 139   dbg_regusage(pic16_dynDirectRegs);
 140   fprintf(stderr,"DirectBitRegs:\n");
 141   dbg_regusage(pic16_dynDirectBitRegs);
 142   fprintf(stderr,"ProcessorRegs:\n");
 143   dbg_regusage(pic16_dynProcessorRegs);
 144
 145 }
 146 #endif
 147
 148 /*-----------------------------------------------------------------*
 149  * void pCodeRegMapLiveRangesInFlow(pCodeFlow *pcfl)
 150  *-----------------------------------------------------------------*/
 151 static void pCodeRegMapLiveRangesInFlow(pCodeFlow *pcfl)
 152 {
 153
 154   pCode *pc=NULL;
 155   pCode *pcprev=NULL;
 156
 157   regs *reg;
 158
 159   if(!pcfl)
 160     return;
 161
 162
 163   pc = pic16_findNextInstruction(pcfl->pc.next);
 164
 165   while(pic16_isPCinFlow(pc,PCODE(pcfl))) {
 166
 167
 168     reg = pic16_getRegFromInstruction(pc);
 169
 170     if(reg) {
 171
 172 #if 0
 173       fprintf(stderr, "flow seq %d, inst seq %d  %s  ",PCODE(pcfl)->seq,pc->seq,reg->name);
 174       fprintf(stderr, "addr = 0x%03x, type = %d  rIdx=0x%03x",
 175               reg->address,reg->type,reg->rIdx);
 176       fprintf(stderr, "command = %s\n", PCI(pc)->mnemonic);
 177
 178 #endif
 179
 180       addSetIfnotP(& (PCFL(pcfl)->registers), reg);
 181
 182       if((PCC_REGISTER | PCC_LITERAL) & PCI(pc)->inCond)
 183         addSetIfnotP(& (reg->reglives.usedpFlows), pcfl);
 184
 185       if(PCC_REGISTER & PCI(pc)->outCond)
 186         addSetIfnotP(& (reg->reglives.assignedpFlows), pcfl);
 187
 188       addSetIfnotP(& (reg->reglives.usedpCodes), pc);
 189
 190 #if 1
 191         /* check to see if this pCode has 2 memory operands,
 192            and set up the second operand too */
 193         if(PCI(pc)->is2MemOp) {
 194                         reg = pic16_getRegFromInstruction2(pc);
 195
 196 //                      fprintf(stderr, "trying to get second operand from pCode reg= %s\n", reg->name);
 197                         addSetIfnotP(& (PCFL(pcfl)->registers), reg);
 198                         addSetIfnotP(& (reg->reglives.usedpCodes), pc);
 199
 200         }
 201 #endif
 202
 203     }
 204
 205
 206     pcprev = pc;
 207     pc = pic16_findNextInstruction(pc->next);
 208
 209   }
 210
 211 }
 212
 213 /*-----------------------------------------------------------------*
 214  * void pic16_pCodeRegMapLiveRanges(pBlock *pb)
 215  *-----------------------------------------------------------------*/
 216 void pic16_pCodeRegMapLiveRanges(pBlock *pb)
 217 {
 218   pCode *pcflow;
 219
 220   for( pcflow = pic16_findNextpCode(pb->pcHead, PC_FLOW);
 221        pcflow != NULL;
 222        pcflow = pic16_findNextpCode(pcflow->next, PC_FLOW) ) {
 223
 224     if(!isPCFL(pcflow)) {
 225       fprintf(stderr, "pCodeRegMapLiveRanges - pcflow is not a flow object ");
 226       continue;
 227     }
 228     pCodeRegMapLiveRangesInFlow(PCFL(pcflow));
 229   }
 230
 231 #if 0
 232   for( pcflow = pic16_findNextpCode(pb->pcHead, PC_FLOW);
 233        pcflow != NULL;
 234        pcflow = pic16_findNextpCode(pcflow->next, PC_FLOW) ) {
 235
 236     regs *r = setFirstItem(PCFL(pcflow)->registers);
 237     fprintf(stderr,"flow seq %d\n", pcflow->seq);
 238
 239     while (r) {
 240       fprintf(stderr, "  %s\n",r->name);
 241       r = setNextItem(PCFL(pcflow)->registers);
 242
 243     }
 244
 245   }
 246 #endif
 247
 248 //  dbg_dumpregusage();
 249
 250 }
 251
 252
 253 /*-----------------------------------------------------------------*
 254  *
 255  *-----------------------------------------------------------------*/
 256 static void Remove1pcode(pCode *pc, regs *reg)
 257 {
 258   pCode *pcn=NULL;
 259
 260   if(!reg || !pc)
 261     return;
 262
 263   deleteSetItem (&(reg->reglives.usedpCodes),pc);
 264
 265 #if 0
 266   fprintf(stderr,"removing instruction:\n");
 267   pc->print(stderr,pc);
 268 #endif
 269
 270   if(PCI(pc)->label) {
 271     pcn = pic16_findNextInstruction(pc->next);
 272
 273     if(pcn)
 274       PCI(pcn)->label = pic16_pBranchAppend(PCI(pcn)->label,PCI(pc)->label);
 275   }
 276
 277   if(PCI(pc)->cline) {
 278     if(!pcn)
 279       pcn = pic16_findNextInstruction(pc->next);
 280
 281     if(pcn) {
 282       if(PCI(pcn)->cline) {
 283         //fprintf(stderr, "source line has been optimized completely out\n");
 284         //pc->print(stderr,pc);
 285       } else {
 286         PCI(pcn)->cline = PCI(pc)->cline;
 287       }
 288     }
 289   }
 290
 291   pc->destruct(pc);
 292
 293 }
 294
 295 /*-----------------------------------------------------------------*
 296  * void RemoveRegsFromSet(set *regset)
 297  *
 298  *-----------------------------------------------------------------*/
 299 static void  RemoveRegsFromSet(set *regset)
 300 {
 301   regs *reg;
 302   int used;
 303
 304   while(regset) {
 305     reg = regset->item;
 306     regset = regset->next;
 307
 308     used = elementsInSet(reg->reglives.usedpCodes);
 309
 310     if(used <= 1) {
 311
 312 //      fprintf(stderr," reg %s isfree=%d, wasused=%d\n",reg->name,reg->isFree,reg->wasUsed);
 313       if(used == 0) {
 314 //              fprintf(stderr,"%s:%d: getting rid of reg %s\n",__FILE__, __LINE__, reg->name);
 315         reg->isFree = 1;
 316         reg->wasUsed = 0;
 317       } else {
 318         pCode *pc;
 319
 320
 321         pc = setFirstItem(reg->reglives.usedpCodes);
 322
 323         if(reg->type == REG_SFR) {
 324                 fprintf(stderr, "not removing SFR reg %s even though used only once\n",reg->name);
 325           continue;
 326         }
 327
 328
 329         if(isPCI(pc)) {
 330           if(PCI(pc)->label) {
 331             pCode *pcn = pic16_findNextInstruction(pc->next);
 332
 333             if(pcn && PCI(pcn)->label) {
 334               //fprintf(stderr,"can't delete instruction with label...\n");
 335               //pc->print(stderr,pc);
 336               continue;
 337             }
 338             /* Move the label to the next instruction */
 339
 340             PCI(pcn)->label = PCI(pc)->label;
 341
 342           }
 343
 344           if(isPCI_SKIP(pc)) {
 345             regs *r = pic16_getRegFromInstruction(pc);
 346             fprintf(stderr, "WARNING, a skip instruction is being optimized out\n");
 347             pc->print(stderr,pc);
 348             fprintf(stderr,"reg %s, type =%d\n",r->name, r->type);
 349           }
 350 //              fprintf(stderr,"%s:%d: removing reg %s because it is used only once\n",__FILE__, __LINE__, reg->name);
 351           Remove1pcode(pc, reg);
 352           /*
 353             pic16_unlinkpCode(pc);
 354             deleteSetItem (&(reg->reglives.usedpCodes),pc);
 355           */
 356           reg->isFree = 1;
 357           reg->wasUsed = 0;
 358           total_registers_saved++;  // debugging stats.
 359         }
 360       }
 361     }
 362
 363   }
 364 }
 365 /*-----------------------------------------------------------------*
 366  * void pic16_RemoveUnusedRegisters(void)
 367  *
 368  *-----------------------------------------------------------------*/
 369 void pic16_RemoveUnusedRegisters(void)
 370 {
 371   /* First, get rid of registers that are used only one time */
 372
 373   //RemoveRegsFromSet(pic16_dynInternalRegs);
 374   RemoveRegsFromSet(pic16_dynAllocRegs);
 375   RemoveRegsFromSet(pic16_dynStackRegs);
 376   /*
 377     don't do DirectRegs yet - there's a problem with arrays
 378   RemoveRegsFromSet(pic16_dynDirectRegs);
 379   */
 380   RemoveRegsFromSet(pic16_dynDirectBitRegs);
 381
 382   if(total_registers_saved) fprintf(stderr, " *** Saved %d registers ***\n", total_registers_saved);
 383 }
 384
 385
 386 /*-----------------------------------------------------------------*
 387  *
 388  *-----------------------------------------------------------------*/
 389 static void Remove2pcodes(pCode *pcflow, pCode *pc1, pCode *pc2, regs *reg, int can_free)
 390 {
 391   if(!reg)
 392     return;
 393
 394   if(pc1)
 395     Remove1pcode(pc1, reg);
 396
 397   if(pc2) {
 398     Remove1pcode(pc2, reg);
 399     deleteSetItem (&(PCFL(pcflow)->registers), reg);
 400
 401     if(can_free) {
 402       reg->isFree = 1;
 403       reg->wasUsed = 0;
 404     }
 405
 406   }
 407
 408   pCodeRegMapLiveRangesInFlow(PCFL(pcflow));
 409 }
 410
 411 /*-----------------------------------------------------------------*
 412  *
 413  *-----------------------------------------------------------------*/
 414 static int regUsedinRange(pCode *pc1, pCode *pc2, regs *reg)
 415 {
 416   int i=0;
 417   regs *testreg;
 418
 419   do {
 420     testreg = pic16_getRegFromInstruction(pc1);
 421     if(testreg && (testreg->rIdx == reg->rIdx)) {
 422       return 1;
 423     }
 424
 425     pc1 = pic16_findNextInstruction(pc1->next);
 426
 427   } while (pc1 && (pc1 != pc2) && (i++ < 100)) ;
 428
 429   if(i >= 100)
 430     fprintf(stderr, "warning, regUsedinRange searched through too many pcodes\n");
 431
 432   return 0;
 433 }
 434
 435 /*-----------------------------------------------------------------*
 436  * void pCodeOptime2pCodes(pCode *pc1, pCode *pc2)
 437  *
 438  * ADHOC pattern checking
 439  * Now look for specific sequences that are easy to optimize.
 440  * Many of these sequences are characteristic of the compiler
 441  * (i.e. it'd probably be a waste of time to apply these adhoc
 442  * checks to hand written assembly.)
 443  *
 444  *
 445  *-----------------------------------------------------------------*/
 446 static int pCodeOptime2pCodes(pCode *pc1, pCode *pc2, pCode *pcfl_used, regs *reg, int can_free, int optimize_level)
 447 {
 448   pCode *pct1, *pct2;
 449   regs  *reg1, *reg2;
 450
 451   int t = total_registers_saved;
 452
 453   if(pc2->seq < pc1->seq) {
 454     pct1 = pc2;
 455     pc2 = pc1;
 456     pc1 = pct1;
 457   }
 458 /*
 459   fprintf(stderr,"pCodeOptime2pCodes\n");
 460   pc1->print(stderr,pc1);
 461   pc2->print(stderr,pc2);
 462 */
 463   if((PCI(pc1)->op == POC_CLRF) && (PCI(pc2)->op == POC_MOVFW) ){
 464
 465     /*
 466       clrf  reg
 467       stuff...
 468       movf  reg,w
 469
 470       can be replaced with
 471
 472       stuff...
 473       movlw 0
 474     */
 475
 476     pCode *newpc;
 477     //fprintf(stderr, "   CLRF/MOVFW. instruction after MOVFW is:\n");
 478     pct1 = pic16_findNextInstruction(pc2->next);
 479
 480     if(PCI(pct1)->op == POC_MOVWF) {
 481       newpc = pic16_newpCode(POC_CLRF, PCI(pct1)->pcop);
 482       pct1->destruct(pct1);
 483     } else {
 484       newpc = pic16_newpCode(POC_MOVLW, pic16_newpCodeOpLit(0));
 485     }
 486
 487     pic16_pCodeInsertAfter(pc2, newpc);
 488     PCI(newpc)->pcflow = PCFL(pcfl_used);
 489     newpc->seq = pc2->seq;
 490
 491     Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
 492     total_registers_saved++;  // debugging stats.
 493
 494   } else if((PCI(pc1)->op == POC_CLRF) && (PCI(pc2)->op == POC_IORFW) ){
 495     //fprintf(stderr, "   CLRF/IORFW.\n");
 496
 497     pct2 = pic16_findNextInstruction(pc2->next);
 498
 499     if(pic16_pCodeSearchCondition(pct2, PCC_Z) > 0) {
 500       pct2 = pic16_newpCode(POC_IORLW, pic16_newpCodeOpLit(0));
 501       pct2->seq = pc2->seq;
 502       PCI(pct2)->pcflow = PCFL(pcfl_used);
 503       pic16_pCodeInsertAfter(pc1,pct2);
 504     }
 505     Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
 506     total_registers_saved++;  // debugging stats.
 507
 508   }  else if(PCI(pc1)->op == POC_MOVWF) {
 509
 510     pct2 = pic16_findNextInstruction(pc2->next);
 511
 512     if(PCI(pc2)->op == POC_MOVFW) {
 513       /*
 514         fprintf(stderr, "   MOVWF/MOVFW. instruction after MOVFW is:\n");
 515         pct2->print(stderr,pct2);
 516       */
 517
 518       if(PCI(pct2)->op == POC_MOVWF) {
 519         /*
 520           Change:
 521
 522             movwf   reg
 523
 524             stuff...
 525
 526             movf    reg,w
 527             movwf   reg2
 528
 529           To:
 530
 531
 532         */
 533         reg2 = pic16_getRegFromInstruction(pct2);
 534         //if(reg2 && !regUsedinRange(pc1,pc2,reg2) && (reg2->type != REG_SFR)) {
 535         if(reg2 && !regUsedinRange(pc1,pc2,reg2)) {
 536
 537           if(pic16_pCodeSearchCondition(pct2, PCC_Z) < 1) {
 538             pCode *pct3 = pic16_findNextInstruction(pct2->next);
 539             pct2->seq = pc1->seq;
 540             pic16_unlinkpCode(pct2);
 541             pic16_pCodeInsertAfter(pic16_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 = pic16_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 = pic16_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 = pic16_newpCode(PCI(pc2)->op, PCI(pct1)->pcop);
 604           pic16_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             pic16_unlinkpCode(pc1);
 614             pic16_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 = pic16_newpCode(POC_MOVFW, PCI(pc1)->pcop);
 628           pic16_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 static 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 //      fprintf(stderr, "%s:%d register %s used %d times in pCode\n", __FILE__, __LINE__, reg->name, used);
 673     if(used == 2) {
 674
 675       /*
 676        * In this section, all registers that are used in only in two
 677        * instructions are examined. If possible, they're optimized out.
 678        */
 679
 680 /*
 681       fprintf (stderr, "OptimizeRegUsage: %s  addr=0x%03x rIdx=0x%03x type=%d used=%d\n",
 682                reg->name,
 683                reg->address,
 684                reg->rIdx, reg->type, used);
 685 */
 686       pc1 = setFirstItem(reg->reglives.usedpCodes);
 687       pc2 = setNextItem(reg->reglives.usedpCodes);
 688
 689       if(pcfl_used && pcfl_assigned) {
 690
 691         /*
 692            expected case - the register has been assigned a value and is
 693            subsequently used
 694         */
 695
 696         //fprintf(stderr," used only twice\n");
 697         if(pcfl_used->seq == pcfl_assigned->seq) {
 698
 699           //fprintf(stderr, "  and used in same flow\n");
 700
 701           pCodeOptime2pCodes(pc1, pc2, pcfl_used, reg, 1,optimize_level);
 702
 703         } else {
 704           // fprintf(stderr, "  and used in different flows\n");
 705
 706         }
 707
 708       } else if(pcfl_used) {
 709
 710         /*
 711           register has been used twice without ever being assigned */
 712         //fprintf(stderr,"WARNING %s: reg %s used without being assigned\n",__FUNCTION__,reg->name);
 713
 714       } else {
 715         //fprintf(stderr,"WARNING %s: reg %s assigned without being used\n",__FUNCTION__,reg->name);
 716         Remove2pcodes(pcfl_assigned, pc1, pc2, reg, 1);
 717         total_registers_saved++;  // debugging stats.
 718       }
 719     } else {
 720
 721       /* register has been used either once, or more than twice */
 722
 723       if(used && !pcfl_used && pcfl_assigned) {
 724         pCode *pc;
 725
 726 //              fprintf(stderr,"WARNING %s: reg %s assigned without being used\n",__FUNCTION__,reg->name);
 727
 728         pc = setFirstItem(reg->reglives.usedpCodes);
 729         while(pc) {
 730
 731           pcfl_assigned = PCODE(PCI(pc)->pcflow);
 732           Remove1pcode(pc, reg);
 733
 734           deleteSetItem (&(PCFL(pcfl_assigned)->registers), reg);
 735           /*
 736           deleteSetItem (&(reg->reglives.usedpCodes),pc);
 737           pc->destruct(pc);
 738           */
 739           pc = setNextItem(reg->reglives.usedpCodes);
 740         }
 741
 742
 743         reg->isFree = 1;
 744         reg->wasUsed = 0;
 745
 746         total_registers_saved++;  // debugging stats.
 747       } else if( (used > 2) && optimize_multi_uses) {
 748
 749         set *rset1=NULL;
 750         set *rset2=NULL;
 751         int searching=1;
 752
 753         pCodeFlow *pcfl1=NULL, *pcfl2=NULL;
 754
 755         /* examine the number of times this register is used */
 756
 757
 758         rset1 = reg->reglives.usedpCodes;
 759         while(rset1 && searching) {
 760
 761           pc1 = rset1->item;
 762           rset2 = rset1->next;
 763
 764           if(pc1 && isPCI(pc1) &&  ( (pcfl1 = PCI(pc1)->pcflow) != NULL) ) {
 765
 766             //while(rset2 && searching) {
 767             if(rset2) {
 768
 769               pc2 = rset2->item;
 770               if(pc2 && isPCI(pc2)  &&  ( (pcfl2 = PCI(pc2)->pcflow) != NULL) )  {
 771                 if(pcfl2 == pcfl1) {
 772
 773                   if(pCodeOptime2pCodes(pc1, pc2, pcfl_used, reg, 0,optimize_level))
 774                     searching = 0;
 775                 }
 776               }
 777
 778               //rset2 = rset2->next;
 779
 780             }
 781           }
 782           rset1 = rset1->next;
 783         }
 784       }
 785     }
 786
 787   }
 788
 789 }
 790 /*-----------------------------------------------------------------*
 791  * void pic16_pCodeRegOptimeRegUsage(pBlock *pb)
 792  *-----------------------------------------------------------------*/
 793 void pic16_pCodeRegOptimizeRegUsage(int level)
 794 {
 795
 796   int passes;
 797   int saved = 0;
 798   int t = total_registers_saved;
 799
 800   if(!register_optimization)
 801     return;
 802 #define OPT_PASSES 4
 803   passes = OPT_PASSES;
 804
 805   do {
 806     saved = total_registers_saved;
 807
 808     /* Identify registers used in one flow sequence */
 809     OptimizeRegUsage(pic16_dynAllocRegs,level, (OPT_PASSES-passes));
 810     OptimizeRegUsage(pic16_dynStackRegs,level, (OPT_PASSES-passes));
 811     OptimizeRegUsage(pic16_dynDirectRegs,0, (OPT_PASSES-passes));
 812
 813     if(total_registers_saved != saved)
 814       fprintf(stderr, " *** pass %d, Saved %d registers, total saved %d ***\n",
 815               (1+OPT_PASSES-passes),total_registers_saved-saved,total_registers_saved);
 816
 817     passes--;
 818
 819   } while( passes && ((total_registers_saved != saved) || (passes==OPT_PASSES-1)) );
 820
 821   if(total_registers_saved == t)
 822     fprintf(stderr, "No registers saved on this pass\n");
 823
 824
 825 /*
 826   fprintf(stderr,"dynamically allocated regs:\n");
 827   dbg_regusage(pic16_dynAllocRegs);
 828   fprintf(stderr,"stack regs:\n");
 829   dbg_regusage(pic16_dynStackRegs);
 830   fprintf(stderr,"direct regs:\n");
 831   dbg_regusage(pic16_dynDirectRegs);
 832 */
 833 }
 834
 835
 836 /*-----------------------------------------------------------------*
 837  * void RegsUnMapLiveRanges(set *regset)
 838  *
 839  *-----------------------------------------------------------------*/
 840 static void  RegsSetUnMapLiveRanges(set *regset)
 841 {
 842   regs *reg;
 843
 844   while(regset) {
 845     reg = regset->item;
 846     regset = regset->next;
 847
 848
 849     deleteSet(&reg->reglives.usedpCodes);
 850     deleteSet(&reg->reglives.usedpFlows);
 851     deleteSet(&reg->reglives.assignedpFlows);
 852
 853   }
 854
 855 }
 856
 857 void  pic16_RegsUnMapLiveRanges(void)
 858 {
 859
 860   RegsSetUnMapLiveRanges(pic16_dynAllocRegs);
 861   RegsSetUnMapLiveRanges(pic16_dynStackRegs);
 862   RegsSetUnMapLiveRanges(pic16_dynDirectRegs);
 863   RegsSetUnMapLiveRanges(pic16_dynProcessorRegs);
 864   RegsSetUnMapLiveRanges(pic16_dynDirectBitRegs);
 865   RegsSetUnMapLiveRanges(pic16_dynInternalRegs);
 866
 867 }