git.gag.com Git - debian/cc1111/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
  41 #define DEBUG_REMOVE1PCODE      0
  42 #define HAVE_DBGREGUSAGE        0
  43
  44
  45 extern void pic16_pCodeInsertAfter(pCode *pc1, pCode *pc2);
  46 extern pCode * pic16_findPrevInstruction(pCode *pci);
  47 extern pBranch * pic16_pBranchAppend(pBranch *h, pBranch *n);
  48 void pic16_unlinkpCode(pCode *pc);
  49 extern int pic16_pCodeSearchCondition(pCode *pc, unsigned int cond);
  50
  51 static int total_registers_saved=0;
  52 static int register_optimization=1;
  53
  54 /*-----------------------------------------------------------------*
  55  * void AddRegToFlow(regs *reg, pCodeFlow *pcfl)
  56  *-----------------------------------------------------------------*/
  57 /*
  58 void AddRegToFlow(regs *reg, pCodeFlow *pcfl)
  59 {
  60
  61   if(!reg || ! pcfl || !isPCFL(pcflow))
  62     return;
  63
  64   if(!pcfl->registers)
  65     pcfl->registers =  newSet();
  66
  67 }
  68 */
  69
  70
  71 /*-----------------------------------------------------------------*
  72  *
  73  *-----------------------------------------------------------------*/
  74
  75 #if HAVE_DBGREGUSAGE
  76 static void dbg_regusage(set *fregs)
  77 {
  78   regs *reg;
  79   pCode *pcfl;
  80   pCode *pc;
  81
  82
  83   for (reg = setFirstItem(fregs) ; reg ;
  84        reg = setNextItem(fregs)) {
  85
  86     if(elementsInSet(reg->reglives.usedpCodes)) {
  87
  88       fprintf (stderr, "%s  addr=0x%03x rIdx=0x%03x",
  89                reg->name,
  90                reg->address,
  91                reg->rIdx);
  92
  93       pcfl = setFirstItem(reg->reglives.usedpFlows);
  94       if(pcfl)
  95         fprintf(stderr, "\n   used in seq");
  96
  97       while(pcfl) {
  98         fprintf(stderr," 0x%03x",pcfl->seq);
  99         pcfl = setNextItem(reg->reglives.usedpFlows);
 100       }
 101
 102       pcfl = setFirstItem(reg->reglives.assignedpFlows);
 103       if(pcfl)
 104         fprintf(stderr, "\n   assigned in seq");
 105
 106       while(pcfl) {
 107         fprintf(stderr," 0x%03x",pcfl->seq);
 108         pcfl = setNextItem(reg->reglives.assignedpFlows);
 109       }
 110
 111       pc = setFirstItem(reg->reglives.usedpCodes);
 112       if(pc)
 113         fprintf(stderr, "\n   used in instructions ");
 114
 115       while(pc) {
 116         pcfl = PCODE(PCI(pc)->pcflow);
 117         if(pcfl)
 118           fprintf(stderr," 0x%03x:",pcfl->seq);
 119         fprintf(stderr,"0x%03x",pc->seq);
 120
 121         pc = setNextItem(reg->reglives.usedpCodes);
 122       }
 123
 124       fprintf(stderr, "\n");
 125     }
 126   }
 127 }
 128
 129 /*-----------------------------------------------------------------*
 130  *
 131  *-----------------------------------------------------------------*/
 132
 133 //static
 134 void dbg_dumpregusage(void)
 135 {
 136
 137   fprintf(stderr,"***  Register Usage  ***\n");
 138   fprintf(stderr,"InternalRegs:\n");
 139   dbg_regusage(pic16_dynInternalRegs);
 140   fprintf(stderr,"AllocRegs:\n");
 141   dbg_regusage(pic16_dynAllocRegs);
 142   fprintf(stderr,"StackRegs:\n");
 143   dbg_regusage(pic16_dynStackRegs);
 144   fprintf(stderr,"DirectRegs:\n");
 145   dbg_regusage(pic16_dynDirectRegs);
 146   fprintf(stderr,"DirectBitRegs:\n");
 147   dbg_regusage(pic16_dynDirectBitRegs);
 148   fprintf(stderr,"ProcessorRegs:\n");
 149   dbg_regusage(pic16_dynProcessorRegs);
 150
 151 }
 152 #endif
 153
 154 /*-----------------------------------------------------------------*
 155  * void pCodeRegMapLiveRangesInFlow(pCodeFlow *pcfl)
 156  *-----------------------------------------------------------------*/
 157 static void pCodeRegMapLiveRangesInFlow(pCodeFlow *pcfl)
 158 {
 159
 160   pCode *pc=NULL;
 161   pCode *pcprev=NULL;
 162
 163   regs *reg;
 164
 165   if(!pcfl)
 166     return;
 167
 168
 169   pc = pic16_findNextInstruction(pcfl->pc.next);
 170
 171   while(pic16_isPCinFlow(pc,PCODE(pcfl))) {
 172
 173
 174     reg = pic16_getRegFromInstruction(pc);
 175
 176     if(reg && (reg->type != REG_TMP)) {
 177
 178 #if 0
 179       fprintf(stderr, "reg= %p\n", reg);
 180       fprintf(stderr, "flow seq %d, inst seq %d  %s  ",PCODE(pcfl)->seq,pc->seq,reg->name);
 181       fprintf(stderr, "addr = 0x%03x, type = %d  rIdx=0x%03x ",
 182               reg->address,reg->type,reg->rIdx);
 183       fprintf(stderr, "command = %s\n", PCI(pc)->mnemonic);
 184
 185 #endif
 186
 187 //      fprintf(stderr, "%s:%d: trying to get first operand from pCode reg= %s\n", __FILE__, __LINE__, reg->name);
 188       addSetIfnotP(& (PCFL(pcfl)->registers), reg);
 189
 190       if((PCC_REGISTER | PCC_LITERAL) & PCI(pc)->inCond)
 191         addSetIfnotP(& (reg->reglives.usedpFlows), pcfl);
 192
 193       if(PCC_REGISTER & PCI(pc)->outCond)
 194         addSetIfnotP(& (reg->reglives.assignedpFlows), pcfl);
 195
 196         addSetIfnotP(& (reg->reglives.usedpCodes), pc);
 197
 198 //    reg->wasUsed=1;
 199
 200 #if 1
 201         /* check to see if this pCode has 2 memory operands,
 202            and set up the second operand too */
 203         if(PCI(pc)->is2MemOp) {
 204                         reg = pic16_getRegFromInstruction2(pc);
 205                         if(reg) {
 206 //                              fprintf(stderr, "%s:%d: trying to get second operand from pCode reg= %s\n", __FILE__, __LINE__, reg->name);
 207                                 addSetIfnotP(& (PCFL(pcfl)->registers), reg);
 208
 209                                 if((PCC_REGISTER | PCC_LITERAL) & PCI(pc)->inCond)
 210                                         addSetIfnotP(& (reg->reglives.usedpFlows), pcfl);
 211
 212                                 if((PCC_REGISTER | PCC_REGISTER2) & PCI(pc)->outCond)
 213                                         addSetIfnotP(& (reg->reglives.assignedpFlows), pcfl);
 214
 215                                 addSetIfnotP(& (reg->reglives.usedpCodes), pc);
 216
 217 //                              reg->wasUsed=1;
 218                         }
 219         }
 220 #endif
 221
 222     }
 223
 224
 225     pcprev = pc;
 226     pc = pic16_findNextInstruction(pc->next);
 227
 228   }
 229
 230 }
 231
 232 /*-----------------------------------------------------------------*
 233  * void pic16_pCodeRegMapLiveRanges(pBlock *pb)
 234  *-----------------------------------------------------------------*/
 235 void pic16_pCodeRegMapLiveRanges(pBlock *pb)
 236 {
 237   pCode *pcflow;
 238
 239   for( pcflow = pic16_findNextpCode(pb->pcHead, PC_FLOW);
 240        pcflow != NULL;
 241        pcflow = pic16_findNextpCode(pcflow->next, PC_FLOW) ) {
 242
 243     if(!isPCFL(pcflow)) {
 244       fprintf(stderr, "pCodeRegMapLiveRanges - pcflow is not a flow object ");
 245       continue;
 246     }
 247     pCodeRegMapLiveRangesInFlow(PCFL(pcflow));
 248   }
 249
 250 #if 0
 251   for( pcflow = pic16_findNextpCode(pb->pcHead, PC_FLOW);
 252        pcflow != NULL;
 253        pcflow = pic16_findNextpCode(pcflow->next, PC_FLOW) ) {
 254
 255     regs *r = setFirstItem(PCFL(pcflow)->registers);
 256     fprintf(stderr,"flow seq %d\n", pcflow->seq);
 257
 258     while (r) {
 259       fprintf(stderr, "  %s\n",r->name);
 260       r = setNextItem(PCFL(pcflow)->registers);
 261
 262     }
 263
 264   }
 265 #endif
 266
 267 #if HAVE_DBGREGUSAGE
 268   dbg_dumpregusage();
 269 #endif
 270
 271 }
 272
 273
 274 /*-----------------------------------------------------------------*
 275  *
 276  *-----------------------------------------------------------------*/
 277 static void Remove1pcode(pCode *pc, regs *reg)
 278 {
 279   pCode *pcn=NULL;
 280
 281   if(!reg || !pc)
 282     return;
 283
 284   deleteSetItem (&(reg->reglives.usedpCodes),pc);
 285
 286 #if DEBUG_REMOVE1PCODE
 287   fprintf(stderr,"removing instruction:\n");
 288   pc->print(stderr,pc);
 289 #endif
 290
 291   if(PCI(pc)->label) {
 292     pcn = pic16_findNextInstruction(pc->next);
 293
 294     if(pcn)
 295       PCI(pcn)->label = pic16_pBranchAppend(PCI(pcn)->label,PCI(pc)->label);
 296   }
 297
 298   if(PCI(pc)->cline) {
 299     if(!pcn)
 300       pcn = pic16_findNextInstruction(pc->next);
 301
 302     if(pcn) {
 303       if(PCI(pcn)->cline) {
 304
 305 #if DEBUG_REMOVE1PCODE
 306         fprintf(stderr, "source line has been optimized completely out\n");
 307         pc->print(stderr,pc);
 308 #endif
 309
 310       } else {
 311         PCI(pcn)->cline = PCI(pc)->cline;
 312       }
 313     }
 314   }
 315
 316   pc->destruct(pc);
 317
 318 }
 319
 320 /*-----------------------------------------------------------------*
 321  * void RemoveRegsFromSet(set *regset)
 322  *
 323  *-----------------------------------------------------------------*/
 324 static void  RemoveRegsFromSet(set *regset)
 325 {
 326   regs *reg;
 327   int used;
 328
 329   while(regset) {
 330     reg = regset->item;
 331     regset = regset->next;
 332
 333     used = elementsInSet(reg->reglives.usedpCodes);
 334
 335     if(used <= 1) {
 336
 337 //      fprintf(stderr," reg %s isfree=%d, wasused=%d\n",reg->name,reg->isFree,reg->wasUsed);
 338
 339       if(used == 0) {
 340
 341 //  fprintf(stderr,"%s:%d: getting rid of reg %s\n",__FILE__, __LINE__, reg->name);
 342
 343         reg->isFree = 1;
 344         reg->wasUsed = 0;
 345       } else {
 346         pCode *pc;
 347
 348
 349         pc = setFirstItem(reg->reglives.usedpCodes);
 350
 351         if(reg->type == REG_SFR) {
 352                 fprintf(stderr, "not removing SFR reg %s even though used only once\n", reg->name);
 353           continue;
 354         }
 355
 356         if(isPCI(pc)) {
 357           if(PCI(pc)->label) {
 358             pCode *pcn = pic16_findNextInstruction(pc->next);
 359
 360             if(pcn && PCI(pcn)->label) {
 361               //fprintf(stderr,"can't delete instruction with label...\n");
 362               //pc->print(stderr,pc);
 363               continue;
 364             }
 365             /* Move the label to the next instruction */
 366
 367             PCI(pcn)->label = PCI(pc)->label;
 368
 369           }
 370
 371           if(isPCI_SKIP(pc)) {
 372             regs *r = pic16_getRegFromInstruction(pc);
 373             fprintf(stderr, "WARNING, a skip instruction is being optimized out\n");
 374             pc->print(stderr,pc);
 375             fprintf(stderr,"reg %s, type =%d\n",r->name, r->type);
 376           }
 377
 378           Remove1pcode(pc, reg);
 379           /*
 380             pic16_unlinkpCode(pc);
 381             deleteSetItem (&(reg->reglives.usedpCodes),pc);
 382           */
 383           reg->isFree = 1;
 384           reg->wasUsed = 0;
 385           total_registers_saved++;  // debugging stats.
 386         }
 387       }
 388     }
 389
 390   }
 391 }
 392 /*-----------------------------------------------------------------*
 393  * void pic16_RemoveUnusedRegisters(void)
 394  *
 395  *-----------------------------------------------------------------*/
 396 void pic16_RemoveUnusedRegisters(void)
 397 {
 398   /* First, get rid of registers that are used only one time */
 399
 400   //RemoveRegsFromSet(pic16_dynInternalRegs);
 401   RemoveRegsFromSet(pic16_dynAllocRegs);
 402   RemoveRegsFromSet(pic16_dynStackRegs);
 403   /*
 404     don't do DirectRegs yet - there's a problem with arrays
 405   RemoveRegsFromSet(pic16_dynDirectRegs);
 406   */
 407   RemoveRegsFromSet(pic16_dynDirectBitRegs);
 408
 409   if(total_registers_saved && pic16_pcode_verbose)
 410         fprintf(stderr, " *** Saved %d registers ***\n", total_registers_saved);
 411 }
 412
 413 static int insideLRBlock(pCode *pc)
 414 {
 415   pCode *pc1;
 416   int t1=-1, t2=-1;
 417
 418     pc1 = pc->prev;
 419     while(pc1) {
 420       if(isPCINFO(pc1) && (PCINF(pc1)->type == INF_LOCALREGS)) {
 421         t1 = PCOLR (PCINF (pc1)->oper1)->type;
 422         break;
 423       }
 424       pc1 = pc1->prev;
 425     }
 426
 427     pc1 = pc->next;
 428     while(pc1) {
 429       if(isPCINFO(pc1) && (PCINF(pc1)->type == INF_LOCALREGS)) {
 430         t2 = PCOLR (PCINF (pc1)->oper1)->type;
 431         break;
 432       }
 433       pc1 = pc1->next;
 434     }
 435
 436     if((t1 == LR_ENTRY_BEGIN && t2 == LR_ENTRY_END)
 437       || (t1 == LR_EXIT_BEGIN && t2 == LR_EXIT_END))
 438         return 1;
 439
 440   return 0;
 441 }
 442
 443
 444 static void RemoveRegFromLRBlock(regs *reg)
 445 {
 446   if(elementsInSet(reg->reglives.usedpCodes) == 2) {
 447     pCode *pc1;
 448
 449       /* only continue if there are just 2 uses of the register,
 450        * in in the local *entry* block and one in the local *exit* block */
 451
 452       /* search for entry block */
 453       pc1 = indexSet(reg->reglives.usedpCodes, 1);
 454
 455       if(insideLRBlock( pc1 )) {
 456         fprintf(stderr, "usedpCodes[0] inside LR block\n");
 457         deleteSetItem(&pc1->pb->tregisters, PCOR(PCI(pc1)->pcop)->r);
 458         Remove1pcode(pc1, reg);
 459       }
 460
 461       pc1 = indexSet(reg->reglives.usedpCodes, 0);
 462       if(insideLRBlock( pc1 )) {
 463         fprintf(stderr, "usedpCodes[1] inside LR block\n");
 464         deleteSetItem(&pc1->pb->tregisters, PCOR(PCI(pc1)->pcop)->r);
 465         Remove1pcode(pc1, reg);
 466       }
 467
 468       /* remove r0x00 */
 469       reg->isFree = 1;
 470       reg->wasUsed = 0;
 471   }
 472 }
 473
 474
 475
 476 /*-----------------------------------------------------------------*
 477  *
 478  *-----------------------------------------------------------------*/
 479 static void Remove2pcodes(pCode *pcflow, pCode *pc1, pCode *pc2, regs *reg, int can_free)
 480 {
 481   if(!reg)
 482     return;
 483
 484 #if 0
 485   fprintf(stderr,"removing 2 instructions:\n");
 486   pc1->print(stderr,pc1);
 487   pc2->print(stderr,pc2);
 488 #endif
 489
 490   if(pc1)
 491     Remove1pcode(pc1, reg);
 492
 493   if(pc2) {
 494     Remove1pcode(pc2, reg);
 495     deleteSetItem (&(PCFL(pcflow)->registers), reg);
 496
 497     if(can_free) {
 498       reg->isFree = 1;
 499       reg->wasUsed = 0;
 500     }
 501
 502   }
 503
 504   pCodeRegMapLiveRangesInFlow(PCFL(pcflow));
 505
 506 #if 1
 507 //  fprintf(stderr, "register %s is used in %d pCodes, assigned in %d pCodes\n", reg->name,
 508 //      elementsInSet(reg->reglives.usedpCodes),
 509 //      elementsInSet(reg->reglives.assignedpFlows));
 510
 511   RemoveRegFromLRBlock(reg);
 512 #endif
 513
 514 }
 515
 516 /*-----------------------------------------------------------------*
 517  *
 518  *-----------------------------------------------------------------*/
 519 static int regUsedinRange(pCode *pc1, pCode *pc2, regs *reg)
 520 {
 521   int i=0;
 522   regs *testreg;
 523
 524   do {
 525     testreg = pic16_getRegFromInstruction(pc1);
 526     if(testreg && (testreg->rIdx == reg->rIdx)) {
 527       return 1;
 528     }
 529
 530     if(PCI(pc1)->is2MemOp) {
 531       testreg = pic16_getRegFromInstruction2(pc1);
 532       if(testreg && (testreg->rIdx == reg->rIdx)) {
 533         return 1;
 534       }
 535     }
 536
 537     pc1 = pic16_findNextInstruction(pc1->next);
 538
 539   } while (pc1 && (pc1 != pc2) && (i++ < 100)) ;
 540
 541   if(i >= 100)
 542     fprintf(stderr, "warning, regUsedinRange searched through too many pcodes\n");
 543
 544   return 0;
 545 }
 546
 547 /*-----------------------------------------------------------------*
 548  * void pCodeOptime2pCodes(pCode *pc1, pCode *pc2)
 549  *
 550  * ADHOC pattern checking
 551  * Now look for specific sequences that are easy to optimize.
 552  * Many of these sequences are characteristic of the compiler
 553  * (i.e. it'd probably be a waste of time to apply these adhoc
 554  * checks to hand written assembly.)
 555  *
 556  *
 557  *-----------------------------------------------------------------*/
 558 static int pCodeOptime2pCodes(pCode *pc1, pCode *pc2, pCode *pcfl_used, regs *reg, int can_free, int optimize_level)
 559 {
 560   pCode *pct1, *pct2;
 561   regs  *reg1, *reg2;
 562
 563   int t = total_registers_saved;
 564
 565   if(reg->type == REG_SFR)return 0;
 566
 567   if(pc2->seq < pc1->seq) {
 568     pct1 = pc2;
 569     pc2 = pc1;
 570     pc1 = pct1;
 571   }
 572 /*
 573   fprintf(stderr,"pCodeOptime2pCodes\n");
 574   pc1->print(stderr,pc1);
 575   pc2->print(stderr,pc2);
 576 */
 577   if((PCI(pc1)->op == POC_CLRF) && (PCI(pc2)->op == POC_MOVFW) ){
 578
 579     /*
 580       clrf  reg
 581       stuff...
 582       movf  reg,w
 583
 584       can be replaced with
 585
 586       stuff...
 587       movlw 0
 588     */
 589
 590     pCode *newpc;
 591     //fprintf(stderr, "   CLRF/MOVFW. instruction after MOVFW is:\n");
 592     pct1 = pic16_findNextInstruction(pc2->next);
 593
 594     if(PCI(pct1)->op == POC_MOVWF) {
 595       newpc = pic16_newpCode(POC_CLRF, PCI(pct1)->pcop);
 596       pct1->destruct(pct1);
 597     } else {
 598       newpc = pic16_newpCode(POC_MOVLW, pic16_newpCodeOpLit(0));
 599     }
 600
 601     pic16_pCodeInsertAfter(pc2, newpc);
 602     PCI(newpc)->pcflow = PCFL(pcfl_used);
 603     newpc->seq = pc2->seq;
 604
 605     /* take care if register is used after pc2, if yes, then don't delete
 606      * clrf reg, because, reg should be initialized with zero */
 607     {
 608       pCode *spc;
 609       int maxSeq=0;
 610
 611         for(spc=setFirstItem(reg->reglives.usedpCodes);spc;spc=setNextItem(reg->reglives.usedpCodes)) {
 612           if(maxSeq < spc->seq)maxSeq = spc->seq;
 613         }
 614
 615 //        fprintf(stderr, "pc1->seq = %d\tpc2->seq = %d\tspc->seq = %d\n", pc1->seq, pc2->seq, maxSeq);
 616
 617         if(maxSeq > pc2->seq) {
 618           /* this means that a pCode uses register after pc2, then
 619            * we can't delete pc1 pCode */
 620           Remove2pcodes(pcfl_used, NULL, pc2, reg, can_free);
 621         } else {
 622           /* we can remove both pCodes */
 623           Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
 624         }
 625     }
 626     total_registers_saved++;  // debugging stats.
 627
 628   } else if((PCI(pc1)->op == POC_CLRF) && (PCI(pc2)->op == POC_IORFW) ){
 629     //fprintf(stderr, "   CLRF/IORFW.\n");
 630
 631     pct2 = pic16_findNextInstruction(pc2->next);
 632
 633     if(pic16_pCodeSearchCondition(pct2, PCC_Z) > 0) {
 634       pct2 = pic16_newpCode(POC_IORLW, pic16_newpCodeOpLit(0));
 635       pct2->seq = pc2->seq;
 636       PCI(pct2)->pcflow = PCFL(pcfl_used);
 637       pic16_pCodeInsertAfter(pc1,pct2);
 638     }
 639     Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
 640     total_registers_saved++;  // debugging stats.
 641
 642   }  else if(PCI(pc1)->op == POC_MOVWF) {
 643
 644     reg1 = pic16_getRegFromInstruction(pc1);
 645
 646     if(reg1->type == REG_SFR)return (total_registers_saved != t);
 647
 648     pct2 = pic16_findNextInstruction(pc2->next);
 649
 650     if(PCI(pc2)->op == POC_MOVFW) {
 651
 652 #if 0
 653         fprintf(stderr, "   MOVWF/MOVFW. instruction after MOVFW is:\n");
 654         pct2->print(stderr,pct2);
 655 #endif
 656
 657       if(PCI(pct2)->op == POC_MOVWF) {
 658         /*
 659           Change:
 660
 661             movwf   reg
 662
 663             stuff...
 664
 665             movf    reg,w
 666             movwf   reg2
 667
 668           To:
 669
 670
 671         */
 672         reg2 = pic16_getRegFromInstruction(pct2);
 673         if(reg2 && !regUsedinRange(pc1,pc2,reg2) && (reg2->type != REG_SFR)) {
 674 //      if(reg2 && !regUsedinRange(pc1,pc2,reg2))
 675
 676           if(pic16_pCodeSearchCondition(pct2, PCC_Z) < 1) {
 677             pCode *pct3 = pic16_findNextInstruction(pct2->next);
 678             pct2->seq = pc1->seq;
 679             pic16_unlinkpCode(pct2);
 680             pic16_pCodeInsertAfter(pic16_findPrevInstruction(pc1->prev),pct2);
 681
 682 #define usesW(x)       ((x) && (isPCI(x)) && ( (PCI(x)->inCond & PCC_W) != 0))
 683
 684             if(usesW(pct3))
 685               ; // Remove2pcodes(pcfl_used, pc1, NULL, reg, can_free);
 686             else {
 687               Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
 688               total_registers_saved++;  // debugging stats.
 689               return 1;
 690             }
 691           } else {
 692 //            fprintf(stderr,"didn't optimize because Z bit is used\n");
 693           }
 694         }
 695 #if 0
 696         fprintf(stderr, " couldn't optimize\n");
 697         if(reg2)
 698           fprintf(stderr, " %s is used in range\n", reg2->name);
 699         else
 700           fprintf(stderr, " reg2 is NULL\n");
 701 #endif
 702       }
 703     }
 704
 705     pct1 = pic16_findPrevInstruction(pc1->prev);
 706     if(pct1 && (PCI(pct1)->pcflow == PCI(pc1)->pcflow)) {
 707
 708       if ( (PCI(pct1)->op == POC_MOVFW) &&
 709            (PCI(pc2)->op == POC_MOVFW)) {
 710
 711         reg1 = pic16_getRegFromInstruction(pct1);
 712         if(reg1 && !regUsedinRange(pc1,pc2,reg1)) {
 713
 714 #if 0
 715             fprintf(stderr, "   MOVF/MOVFW. \n");
 716             fprintf(stderr, "     ...optimizing\n");
 717 #endif
 718
 719           /*
 720             Change:
 721
 722             movf   reg1,w
 723             movwf  reg
 724
 725             stuff...
 726             movf   reg,w
 727
 728             To:
 729
 730             stuff...
 731
 732             movf   reg1,w
 733
 734             Or, if we're not deleting the register then the "To" is:
 735
 736             stuff...
 737
 738             movf   reg1,w
 739             movwf  reg
 740
 741
 742           */
 743           pct2 = pic16_newpCode(PCI(pc2)->op, PCI(pct1)->pcop);
 744           pic16_pCodeInsertAfter(pc2, pct2);
 745           PCI(pct2)->pcflow = PCFL(pcfl_used);
 746           pct2->seq = pc2->seq;
 747
 748           if(can_free) {
 749             Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
 750           } else {
 751             /* If we're not freeing the register then that means (probably)
 752              * the register is needed somewhere else.*/
 753             pic16_unlinkpCode(pc1);
 754             pic16_pCodeInsertAfter(pct2, pc1);
 755
 756             Remove2pcodes(pcfl_used, pc2, NULL, reg, can_free);
 757           }
 758
 759           Remove2pcodes(pcfl_used, pct1, NULL, reg1, 0);
 760           total_registers_saved++;  // debugging stats.
 761
 762         }
 763       } else if ( (PCI(pct1)->op == POC_MOVWF) &&
 764            (PCI(pc2)->op == POC_MOVFW)) {
 765
 766 //         fprintf(stderr,"movwf MOVWF/MOVFW\n");
 767
 768         if(optimize_level > 1 && can_free) {
 769           pct2 = pic16_newpCode(POC_MOVFW, PCI(pc1)->pcop);
 770           pic16_pCodeInsertAfter(pc2, pct2);
 771           Remove2pcodes(pcfl_used, pc1, pc2, reg, 1);
 772           total_registers_saved++;  // debugging stats.
 773         }
 774       }
 775
 776
 777     }
 778
 779   }
 780
 781   return (total_registers_saved != t);
 782 }
 783
 784 /*-----------------------------------------------------------------*
 785  * void pCodeRegOptimeRegUsage(pBlock *pb)
 786  *-----------------------------------------------------------------*/
 787 static void OptimizeRegUsage(set *fregs, int optimize_multi_uses, int optimize_level)
 788 {
 789   regs *reg;
 790   int used;
 791   pCode *pc1=NULL, *pc2=NULL;
 792
 793
 794   while(fregs) {
 795     pCode *pcfl_used, *pcfl_assigned;
 796
 797     /* Step through the set by directly accessing the 'next' pointer.
 798      * We could also step through by using the set API, but the
 799      * the (debug) calls to print instructions affect the state
 800      * of the set pointers */
 801
 802     reg = fregs->item;
 803     fregs = fregs->next;
 804
 805         if(reg->type == REG_SFR) {
 806 //              fprintf(stderr,"skipping SFR: %s\n",reg->name);
 807                 continue;
 808         }
 809
 810     pcfl_used = setFirstItem(reg->reglives.usedpFlows);
 811     pcfl_assigned = setFirstItem(reg->reglives.assignedpFlows);
 812
 813     used = elementsInSet(reg->reglives.usedpCodes);
 814 //      fprintf(stderr, "%s:%d register %s used %d times in pCode\n", __FILE__, __LINE__, reg->name, used);
 815     if(used == 2) {
 816
 817       /*
 818        * In this section, all registers that are used in only in two
 819        * instructions are examined. If possible, they're optimized out.
 820        */
 821
 822 #if 0
 823       fprintf (stderr, "OptimizeRegUsage: %s  addr=0x%03x rIdx=0x%03x type=%d used=%d\n",
 824                reg->name,
 825                reg->address,
 826                reg->rIdx, reg->type, used);
 827 #endif
 828
 829       pc1 = setFirstItem(reg->reglives.usedpCodes);
 830       pc2 = setNextItem(reg->reglives.usedpCodes);
 831
 832       if(pcfl_used && pcfl_assigned) {
 833
 834         /*
 835            expected case - the register has been assigned a value and is
 836            subsequently used
 837         */
 838
 839         //fprintf(stderr," used only twice\n");
 840         if(pcfl_used->seq == pcfl_assigned->seq && !(setNextItem(reg->reglives.usedpFlows)) && !(setNextItem(reg->reglives.assignedpFlows))) {
 841
 842           //fprintf(stderr, "  and used in same flow\n");
 843
 844           pCodeOptime2pCodes(pc1, pc2, pcfl_used, reg, 1,optimize_level);
 845
 846         } else {
 847           // fprintf(stderr, "  and used in different flows\n");
 848
 849         }
 850
 851       } else if(pcfl_used) {
 852
 853         /*
 854           register has been used twice without ever being assigned */
 855         //fprintf(stderr,"WARNING %s: reg %s used without being assigned\n",__FUNCTION__,reg->name);
 856
 857       } else {
 858 //              fprintf(stderr,"WARNING %s: reg %s assigned without being used\n",__FUNCTION__,reg->name);
 859         Remove2pcodes(pcfl_assigned, pc1, pc2, reg, 1);
 860         total_registers_saved++;  // debugging stats.
 861       }
 862     } else {
 863
 864       /* register has been used either once, or more than twice */
 865
 866       if(used && !pcfl_used && pcfl_assigned) {
 867         pCode *pc;
 868
 869                 fprintf(stderr,"WARNING %s: reg %s assigned without being used\n",__FUNCTION__,reg->name);
 870
 871         pc = setFirstItem(reg->reglives.usedpCodes);
 872         while(pc) {
 873
 874           pcfl_assigned = PCODE(PCI(pc)->pcflow);
 875           Remove1pcode(pc, reg);
 876
 877           deleteSetItem (&(PCFL(pcfl_assigned)->registers), reg);
 878           /*
 879           deleteSetItem (&(reg->reglives.usedpCodes),pc);
 880           pc->destruct(pc);
 881           */
 882           pc = setNextItem(reg->reglives.usedpCodes);
 883         }
 884
 885
 886         reg->isFree = 1;
 887         reg->wasUsed = 0;
 888
 889         total_registers_saved++;  // debugging stats.
 890       } else if( (used > 2) && optimize_multi_uses) {
 891
 892         set *rset1=NULL;
 893         set *rset2=NULL;
 894         int searching=1;
 895
 896         pCodeFlow *pcfl1=NULL, *pcfl2=NULL;
 897
 898         /* examine the number of times this register is used */
 899
 900
 901         rset1 = reg->reglives.usedpCodes;
 902         while(rset1 && searching) {
 903
 904           pc1 = rset1->item;
 905           rset2 = rset1->next;
 906
 907           if(pc1 && isPCI(pc1) &&  ( (pcfl1 = PCI(pc1)->pcflow) != NULL) ) {
 908
 909             //while(rset2 && searching) {
 910             if(rset2) {
 911
 912               pc2 = rset2->item;
 913               if(pc2 && isPCI(pc2)  &&  ( (pcfl2 = PCI(pc2)->pcflow) != NULL) )  {
 914                 if(pcfl2 == pcfl1) {
 915
 916                   if(pCodeOptime2pCodes(pc1, pc2, pcfl_used, reg, 0,optimize_level))
 917                     searching = 0;
 918                 }
 919               }
 920
 921               //rset2 = rset2->next;
 922
 923             }
 924           }
 925           rset1 = rset1->next;
 926         }
 927       }
 928     }
 929
 930   }
 931
 932 }
 933 /*-----------------------------------------------------------------*
 934  * void pic16_pCodeRegOptimeRegUsage(pBlock *pb)
 935  *-----------------------------------------------------------------*/
 936 void pic16_pCodeRegOptimizeRegUsage(int level)
 937 {
 938
 939   int passes;
 940   int saved = 0;
 941   int t = total_registers_saved;
 942
 943     if(getenv("NO_REG_OPT"))
 944       return;
 945
 946     if(!register_optimization)
 947       return;
 948
 949 #define OPT_PASSES 8
 950     passes = OPT_PASSES;
 951
 952     do {
 953       saved = total_registers_saved;
 954
 955       /* Identify registers used in one flow sequence */
 956       OptimizeRegUsage(pic16_dynAllocRegs,level, (OPT_PASSES-passes));
 957       OptimizeRegUsage(pic16_dynStackRegs,level, (OPT_PASSES-passes));
 958       OptimizeRegUsage(pic16_dynDirectRegs,0, (OPT_PASSES-passes));
 959
 960       if((total_registers_saved != saved)
 961         && (pic16_pcode_verbose))
 962           fprintf(stderr, " *** pass %d, Saved %d registers, total saved %d ***\n",
 963             (1+OPT_PASSES-passes),total_registers_saved-saved,total_registers_saved);
 964
 965           passes--;
 966
 967     } while( passes && ((total_registers_saved != saved) || (passes==OPT_PASSES-1)) );
 968
 969     if(total_registers_saved == t)
 970       if(pic16_debug_verbose)
 971         fprintf(stderr, "No registers saved on this pass\n");
 972
 973
 974 #if 0
 975     fprintf(stderr,"dynamically allocated regs:\n");
 976     dbg_regusage(pic16_dynAllocRegs);
 977     fprintf(stderr,"stack regs:\n");
 978     dbg_regusage(pic16_dynStackRegs);
 979     fprintf(stderr,"direct regs:\n");
 980     dbg_regusage(pic16_dynDirectRegs);
 981 #endif
 982 }
 983
 984
 985 /*-----------------------------------------------------------------*
 986  * void RegsUnMapLiveRanges(set *regset)
 987  *
 988  *-----------------------------------------------------------------*/
 989 static void  RegsSetUnMapLiveRanges(set *regset)
 990 {
 991   regs *reg;
 992
 993   while(regset) {
 994     reg = regset->item;
 995     regset = regset->next;
 996
 997     deleteSet(&reg->reglives.usedpCodes);
 998     deleteSet(&reg->reglives.usedpFlows);
 999     deleteSet(&reg->reglives.assignedpFlows);
1000
1001   }
1002
1003 }
1004
1005 void  pic16_RegsUnMapLiveRanges(void)
1006 {
1007   RegsSetUnMapLiveRanges(pic16_dynAllocRegs);
1008   RegsSetUnMapLiveRanges(pic16_dynStackRegs);
1009   RegsSetUnMapLiveRanges(pic16_dynDirectRegs);
1010   RegsSetUnMapLiveRanges(pic16_dynProcessorRegs);
1011   RegsSetUnMapLiveRanges(pic16_dynDirectBitRegs);
1012   RegsSetUnMapLiveRanges(pic16_dynInternalRegs);
1013 }