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