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