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