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           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 static int insideLRBlock(pCode *pc)
 400 {
 401   pCode *pc1;
 402   int t1=-1, t2=-1;
 403
 404     pc1 = pc->prev;
 405     while(pc1) {
 406       if(isPCINFO(pc1) && (PCINF(pc1)->type == INF_LOCALREGS)) {
 407         t1 = PCOLR (PCINF (pc1)->oper1)->type;
 408         break;
 409       }
 410       pc1 = pc1->prev;
 411     }
 412
 413     pc1 = pc->next;
 414     while(pc1) {
 415       if(isPCINFO(pc1) && (PCINF(pc1)->type == INF_LOCALREGS)) {
 416         t2 = PCOLR (PCINF (pc1)->oper1)->type;
 417         break;
 418       }
 419       pc1 = pc1->next;
 420     }
 421
 422     if((t1 == LR_ENTRY_BEGIN && t2 == LR_ENTRY_END)
 423       || (t1 == LR_EXIT_BEGIN && t2 == LR_EXIT_END))
 424         return 1;
 425
 426   return 0;
 427 }
 428
 429
 430 static void RemoveRegFromLRBlock(regs *reg)
 431 {
 432   if(elementsInSet(reg->reglives.usedpCodes) == 2) {
 433     pCode *pc1;
 434
 435       /* only continue if there are just 2 uses of the register,
 436        * in in the local *entry* block and one in the local *exit* block */
 437
 438       /* search for entry block */
 439       pc1 = indexSet(reg->reglives.usedpCodes, 1);
 440
 441       if(insideLRBlock( pc1 )) {
 442         fprintf(stderr, "usedpCodes[0] inside LR block\n");
 443         deleteSetItem(&pc1->pb->tregisters, PCOR(PCI(pc1)->pcop)->r);
 444         Remove1pcode(pc1, reg);
 445       }
 446
 447       pc1 = indexSet(reg->reglives.usedpCodes, 0);
 448       if(insideLRBlock( pc1 )) {
 449         fprintf(stderr, "usedpCodes[1] inside LR block\n");
 450         deleteSetItem(&pc1->pb->tregisters, PCOR(PCI(pc1)->pcop)->r);
 451         Remove1pcode(pc1, reg);
 452       }
 453
 454       /* remove r0x00 */
 455       reg->isFree = 1;
 456       reg->wasUsed = 0;
 457   }
 458 }
 459
 460
 461
 462 /*-----------------------------------------------------------------*
 463  *
 464  *-----------------------------------------------------------------*/
 465 static void Remove2pcodes(pCode *pcflow, pCode *pc1, pCode *pc2, regs *reg, int can_free)
 466 {
 467   if(!reg)
 468     return;
 469
 470 #if 0
 471   fprintf(stderr,"removing 2 instructions:\n");
 472   pc1->print(stderr,pc1);
 473   pc2->print(stderr,pc2);
 474 #endif
 475
 476   if(pc1)
 477     Remove1pcode(pc1, reg);
 478
 479   if(pc2) {
 480     Remove1pcode(pc2, reg);
 481     deleteSetItem (&(PCFL(pcflow)->registers), reg);
 482
 483     if(can_free) {
 484       reg->isFree = 1;
 485       reg->wasUsed = 0;
 486     }
 487
 488   }
 489
 490   pCodeRegMapLiveRangesInFlow(PCFL(pcflow));
 491
 492 #if 1
 493 //  fprintf(stderr, "register %s is used in %d pCodes, assigned in %d pCodes\n", reg->name,
 494 //      elementsInSet(reg->reglives.usedpCodes),
 495 //      elementsInSet(reg->reglives.assignedpFlows));
 496
 497   RemoveRegFromLRBlock(reg);
 498 #endif
 499
 500 }
 501
 502 /*-----------------------------------------------------------------*
 503  *
 504  *-----------------------------------------------------------------*/
 505 static int regUsedinRange(pCode *pc1, pCode *pc2, regs *reg)
 506 {
 507   int i=0;
 508   regs *testreg;
 509
 510   do {
 511     testreg = pic16_getRegFromInstruction(pc1);
 512     if(testreg && (testreg->rIdx == reg->rIdx)) {
 513       return 1;
 514     }
 515
 516     if(PCI(pc1)->is2MemOp) {
 517       testreg = pic16_getRegFromInstruction2(pc1);
 518       if(testreg && (testreg->rIdx == reg->rIdx)) {
 519         return 1;
 520       }
 521     }
 522
 523     pc1 = pic16_findNextInstruction(pc1->next);
 524
 525   } while (pc1 && (pc1 != pc2) && (i++ < 100)) ;
 526
 527   if(i >= 100)
 528     fprintf(stderr, "warning, regUsedinRange searched through too many pcodes\n");
 529
 530   return 0;
 531 }
 532
 533 /*-----------------------------------------------------------------*
 534  * void pCodeOptime2pCodes(pCode *pc1, pCode *pc2)
 535  *
 536  * ADHOC pattern checking
 537  * Now look for specific sequences that are easy to optimize.
 538  * Many of these sequences are characteristic of the compiler
 539  * (i.e. it'd probably be a waste of time to apply these adhoc
 540  * checks to hand written assembly.)
 541  *
 542  *
 543  *-----------------------------------------------------------------*/
 544 static int pCodeOptime2pCodes(pCode *pc1, pCode *pc2, pCode *pcfl_used, regs *reg, int can_free, int optimize_level)
 545 {
 546   pCode *pct1, *pct2;
 547   regs  *reg1, *reg2;
 548
 549   int t = total_registers_saved;
 550
 551   if(reg->type == REG_SFR)return 0;
 552
 553   if(pc2->seq < pc1->seq) {
 554     pct1 = pc2;
 555     pc2 = pc1;
 556     pc1 = pct1;
 557   }
 558 /*
 559   fprintf(stderr,"pCodeOptime2pCodes\n");
 560   pc1->print(stderr,pc1);
 561   pc2->print(stderr,pc2);
 562 */
 563   if((PCI(pc1)->op == POC_CLRF) && (PCI(pc2)->op == POC_MOVFW) ){
 564
 565     /*
 566       clrf  reg
 567       stuff...
 568       movf  reg,w
 569
 570       can be replaced with
 571
 572       stuff...
 573       movlw 0
 574     */
 575
 576     pCode *newpc;
 577     //fprintf(stderr, "   CLRF/MOVFW. instruction after MOVFW is:\n");
 578     pct1 = pic16_findNextInstruction(pc2->next);
 579
 580     if(PCI(pct1)->op == POC_MOVWF) {
 581       newpc = pic16_newpCode(POC_CLRF, PCI(pct1)->pcop);
 582       pct1->destruct(pct1);
 583     } else {
 584       newpc = pic16_newpCode(POC_MOVLW, pic16_newpCodeOpLit(0));
 585     }
 586
 587     pic16_pCodeInsertAfter(pc2, newpc);
 588     PCI(newpc)->pcflow = PCFL(pcfl_used);
 589     newpc->seq = pc2->seq;
 590
 591     /* take care if register is used after pc2, if yes, then don't delete
 592      * clrf reg, because, reg should be initialized with zero */
 593     {
 594       pCode *spc;
 595       int maxSeq=0;
 596
 597         for(spc=setFirstItem(reg->reglives.usedpCodes);spc;spc=setNextItem(reg->reglives.usedpCodes)) {
 598           if(maxSeq < spc->seq)maxSeq = spc->seq;
 599         }
 600
 601 //        fprintf(stderr, "pc1->seq = %d\tpc2->seq = %d\tspc->seq = %d\n", pc1->seq, pc2->seq, maxSeq);
 602
 603         if(maxSeq > pc2->seq) {
 604           /* this means that a pCode uses register after pc2, then
 605            * we can't delete pc1 pCode */
 606           Remove2pcodes(pcfl_used, NULL, pc2, reg, can_free);
 607         } else {
 608           /* we can remove both pCodes */
 609           Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
 610         }
 611     }
 612     total_registers_saved++;  // debugging stats.
 613
 614   } else if((PCI(pc1)->op == POC_CLRF) && (PCI(pc2)->op == POC_IORFW) ){
 615     //fprintf(stderr, "   CLRF/IORFW.\n");
 616
 617     pct2 = pic16_findNextInstruction(pc2->next);
 618
 619     if(pic16_pCodeSearchCondition(pct2, PCC_Z) > 0) {
 620       pct2 = pic16_newpCode(POC_IORLW, pic16_newpCodeOpLit(0));
 621       pct2->seq = pc2->seq;
 622       PCI(pct2)->pcflow = PCFL(pcfl_used);
 623       pic16_pCodeInsertAfter(pc1,pct2);
 624     }
 625     Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
 626     total_registers_saved++;  // debugging stats.
 627
 628   }  else if(PCI(pc1)->op == POC_MOVWF) {
 629
 630     reg1 = pic16_getRegFromInstruction(pc1);
 631
 632     if(reg1->type == REG_SFR)return (total_registers_saved != t);
 633
 634     pct2 = pic16_findNextInstruction(pc2->next);
 635
 636     if(PCI(pc2)->op == POC_MOVFW) {
 637
 638 #if 0
 639         fprintf(stderr, "   MOVWF/MOVFW. instruction after MOVFW is:\n");
 640         pct2->print(stderr,pct2);
 641 #endif
 642
 643       if(PCI(pct2)->op == POC_MOVWF) {
 644         /*
 645           Change:
 646
 647             movwf   reg
 648
 649             stuff...
 650
 651             movf    reg,w
 652             movwf   reg2
 653
 654           To:
 655
 656
 657         */
 658         reg2 = pic16_getRegFromInstruction(pct2);
 659         if(reg2 && !regUsedinRange(pc1,pc2,reg2) && (reg2->type != REG_SFR)) {
 660 //      if(reg2 && !regUsedinRange(pc1,pc2,reg2))
 661
 662           if(pic16_pCodeSearchCondition(pct2, PCC_Z) < 1) {
 663             pCode *pct3 = pic16_findNextInstruction(pct2->next);
 664             pct2->seq = pc1->seq;
 665             pic16_unlinkpCode(pct2);
 666             pic16_pCodeInsertAfter(pic16_findPrevInstruction(pc1->prev),pct2);
 667
 668 #define usesW(x)       ((x) && (isPCI(x)) && ( (PCI(x)->inCond & PCC_W) != 0))
 669
 670             if(usesW(pct3))
 671               ; // Remove2pcodes(pcfl_used, pc1, NULL, reg, can_free);
 672             else {
 673               Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
 674               total_registers_saved++;  // debugging stats.
 675               return 1;
 676             }
 677           } else {
 678 //            fprintf(stderr,"didn't optimize because Z bit is used\n");
 679           }
 680         }
 681 #if 0
 682         fprintf(stderr, " couldn't optimize\n");
 683         if(reg2)
 684           fprintf(stderr, " %s is used in range\n", reg2->name);
 685         else
 686           fprintf(stderr, " reg2 is NULL\n");
 687 #endif
 688       }
 689     }
 690
 691     pct1 = pic16_findPrevInstruction(pc1->prev);
 692     if(pct1 && (PCI(pct1)->pcflow == PCI(pc1)->pcflow)) {
 693
 694       if ( (PCI(pct1)->op == POC_MOVFW) &&
 695            (PCI(pc2)->op == POC_MOVFW)) {
 696
 697         reg1 = pic16_getRegFromInstruction(pct1);
 698         if(reg1 && !regUsedinRange(pc1,pc2,reg1)) {
 699
 700 #if 0
 701             fprintf(stderr, "   MOVF/MOVFW. \n");
 702             fprintf(stderr, "     ...optimizing\n");
 703 #endif
 704
 705           /*
 706             Change:
 707
 708             movf   reg1,w
 709             movwf  reg
 710
 711             stuff...
 712             movf   reg,w
 713
 714             To:
 715
 716             stuff...
 717
 718             movf   reg1,w
 719
 720             Or, if we're not deleting the register then the "To" is:
 721
 722             stuff...
 723
 724             movf   reg1,w
 725             movwf  reg
 726
 727
 728           */
 729           pct2 = pic16_newpCode(PCI(pc2)->op, PCI(pct1)->pcop);
 730           pic16_pCodeInsertAfter(pc2, pct2);
 731           PCI(pct2)->pcflow = PCFL(pcfl_used);
 732           pct2->seq = pc2->seq;
 733
 734           if(can_free) {
 735             Remove2pcodes(pcfl_used, pc1, pc2, reg, can_free);
 736           } else {
 737             /* If we're not freeing the register then that means (probably)
 738              * the register is needed somewhere else.*/
 739             pic16_unlinkpCode(pc1);
 740             pic16_pCodeInsertAfter(pct2, pc1);
 741
 742             Remove2pcodes(pcfl_used, pc2, NULL, reg, can_free);
 743           }
 744
 745           Remove2pcodes(pcfl_used, pct1, NULL, reg1, 0);
 746           total_registers_saved++;  // debugging stats.
 747
 748         }
 749       } else if ( (PCI(pct1)->op == POC_MOVWF) &&
 750            (PCI(pc2)->op == POC_MOVFW)) {
 751
 752 //         fprintf(stderr,"movwf MOVWF/MOVFW\n");
 753
 754         if(optimize_level > 1 && can_free) {
 755           pct2 = pic16_newpCode(POC_MOVFW, PCI(pc1)->pcop);
 756           pic16_pCodeInsertAfter(pc2, pct2);
 757           Remove2pcodes(pcfl_used, pc1, pc2, reg, 1);
 758           total_registers_saved++;  // debugging stats.
 759         }
 760       }
 761
 762
 763     }
 764
 765   }
 766
 767   return (total_registers_saved != t);
 768 }
 769
 770 /*-----------------------------------------------------------------*
 771  * void pCodeRegOptimeRegUsage(pBlock *pb)
 772  *-----------------------------------------------------------------*/
 773 static void OptimizeRegUsage(set *fregs, int optimize_multi_uses, int optimize_level)
 774 {
 775   regs *reg;
 776   int used;
 777   pCode *pc1=NULL, *pc2=NULL;
 778
 779
 780   while(fregs) {
 781     pCode *pcfl_used, *pcfl_assigned;
 782
 783     /* Step through the set by directly accessing the 'next' pointer.
 784      * We could also step through by using the set API, but the
 785      * the (debug) calls to print instructions affect the state
 786      * of the set pointers */
 787
 788     reg = fregs->item;
 789     fregs = fregs->next;
 790
 791         if(reg->type == REG_SFR) {
 792 //              fprintf(stderr,"skipping SFR: %s\n",reg->name);
 793                 continue;
 794         }
 795
 796     pcfl_used = setFirstItem(reg->reglives.usedpFlows);
 797     pcfl_assigned = setFirstItem(reg->reglives.assignedpFlows);
 798
 799     used = elementsInSet(reg->reglives.usedpCodes);
 800 //      fprintf(stderr, "%s:%d register %s used %d times in pCode\n", __FILE__, __LINE__, reg->name, used);
 801     if(used == 2) {
 802
 803       /*
 804        * In this section, all registers that are used in only in two
 805        * instructions are examined. If possible, they're optimized out.
 806        */
 807
 808 #if 0
 809       fprintf (stderr, "OptimizeRegUsage: %s  addr=0x%03x rIdx=0x%03x type=%d used=%d\n",
 810                reg->name,
 811                reg->address,
 812                reg->rIdx, reg->type, used);
 813 #endif
 814
 815       pc1 = setFirstItem(reg->reglives.usedpCodes);
 816       pc2 = setNextItem(reg->reglives.usedpCodes);
 817
 818       if(pcfl_used && pcfl_assigned) {
 819
 820         /*
 821            expected case - the register has been assigned a value and is
 822            subsequently used
 823         */
 824
 825         //fprintf(stderr," used only twice\n");
 826         if(pcfl_used->seq == pcfl_assigned->seq && !(setNextItem(reg->reglives.usedpFlows)) && !(setNextItem(reg->reglives.assignedpFlows))) {
 827
 828           //fprintf(stderr, "  and used in same flow\n");
 829
 830           pCodeOptime2pCodes(pc1, pc2, pcfl_used, reg, 1,optimize_level);
 831
 832         } else {
 833           // fprintf(stderr, "  and used in different flows\n");
 834
 835         }
 836
 837       } else if(pcfl_used) {
 838
 839         /*
 840           register has been used twice without ever being assigned */
 841         //fprintf(stderr,"WARNING %s: reg %s used without being assigned\n",__FUNCTION__,reg->name);
 842
 843       } else {
 844 //              fprintf(stderr,"WARNING %s: reg %s assigned without being used\n",__FUNCTION__,reg->name);
 845         Remove2pcodes(pcfl_assigned, pc1, pc2, reg, 1);
 846         total_registers_saved++;  // debugging stats.
 847       }
 848     } else {
 849
 850       /* register has been used either once, or more than twice */
 851
 852       if(used && !pcfl_used && pcfl_assigned) {
 853         pCode *pc;
 854
 855                 fprintf(stderr,"WARNING %s: reg %s assigned without being used\n",__FUNCTION__,reg->name);
 856
 857         pc = setFirstItem(reg->reglives.usedpCodes);
 858         while(pc) {
 859
 860           pcfl_assigned = PCODE(PCI(pc)->pcflow);
 861           Remove1pcode(pc, reg);
 862
 863           deleteSetItem (&(PCFL(pcfl_assigned)->registers), reg);
 864           /*
 865           deleteSetItem (&(reg->reglives.usedpCodes),pc);
 866           pc->destruct(pc);
 867           */
 868           pc = setNextItem(reg->reglives.usedpCodes);
 869         }
 870
 871
 872         reg->isFree = 1;
 873         reg->wasUsed = 0;
 874
 875         total_registers_saved++;  // debugging stats.
 876       } else if( (used > 2) && optimize_multi_uses) {
 877
 878         set *rset1=NULL;
 879         set *rset2=NULL;
 880         int searching=1;
 881
 882         pCodeFlow *pcfl1=NULL, *pcfl2=NULL;
 883
 884         /* examine the number of times this register is used */
 885
 886
 887         rset1 = reg->reglives.usedpCodes;
 888         while(rset1 && searching) {
 889
 890           pc1 = rset1->item;
 891           rset2 = rset1->next;
 892
 893           if(pc1 && isPCI(pc1) &&  ( (pcfl1 = PCI(pc1)->pcflow) != NULL) ) {
 894
 895             //while(rset2 && searching) {
 896             if(rset2) {
 897
 898               pc2 = rset2->item;
 899               if(pc2 && isPCI(pc2)  &&  ( (pcfl2 = PCI(pc2)->pcflow) != NULL) )  {
 900                 if(pcfl2 == pcfl1) {
 901
 902                   if(pCodeOptime2pCodes(pc1, pc2, pcfl_used, reg, 0,optimize_level))
 903                     searching = 0;
 904                 }
 905               }
 906
 907               //rset2 = rset2->next;
 908
 909             }
 910           }
 911           rset1 = rset1->next;
 912         }
 913       }
 914     }
 915
 916   }
 917
 918 }
 919 /*-----------------------------------------------------------------*
 920  * void pic16_pCodeRegOptimeRegUsage(pBlock *pb)
 921  *-----------------------------------------------------------------*/
 922 void pic16_pCodeRegOptimizeRegUsage(int level)
 923 {
 924
 925   int passes;
 926   int saved = 0;
 927   int t = total_registers_saved;
 928
 929     if(getenv("NO_REG_OPT"))
 930       return;
 931
 932     if(!register_optimization)
 933       return;
 934
 935 #define OPT_PASSES 8
 936     passes = OPT_PASSES;
 937
 938     do {
 939       saved = total_registers_saved;
 940
 941       /* Identify registers used in one flow sequence */
 942       OptimizeRegUsage(pic16_dynAllocRegs,level, (OPT_PASSES-passes));
 943       OptimizeRegUsage(pic16_dynStackRegs,level, (OPT_PASSES-passes));
 944       OptimizeRegUsage(pic16_dynDirectRegs,0, (OPT_PASSES-passes));
 945
 946       if((total_registers_saved != saved)
 947         && (pic16_pcode_verbose))
 948           fprintf(stderr, " *** pass %d, Saved %d registers, total saved %d ***\n",
 949             (1+OPT_PASSES-passes),total_registers_saved-saved,total_registers_saved);
 950
 951           passes--;
 952
 953     } while( passes && ((total_registers_saved != saved) || (passes==OPT_PASSES-1)) );
 954
 955     if(total_registers_saved == t)
 956       if(pic16_debug_verbose)
 957         fprintf(stderr, "No registers saved on this pass\n");
 958
 959
 960 #if 0
 961     fprintf(stderr,"dynamically allocated regs:\n");
 962     dbg_regusage(pic16_dynAllocRegs);
 963     fprintf(stderr,"stack regs:\n");
 964     dbg_regusage(pic16_dynStackRegs);
 965     fprintf(stderr,"direct regs:\n");
 966     dbg_regusage(pic16_dynDirectRegs);
 967 #endif
 968 }
 969
 970
 971 /*-----------------------------------------------------------------*
 972  * void RegsUnMapLiveRanges(set *regset)
 973  *
 974  *-----------------------------------------------------------------*/
 975 static void  RegsSetUnMapLiveRanges(set *regset)
 976 {
 977   regs *reg;
 978
 979   while(regset) {
 980     reg = regset->item;
 981     regset = regset->next;
 982
 983     deleteSet(&reg->reglives.usedpCodes);
 984     deleteSet(&reg->reglives.usedpFlows);
 985     deleteSet(&reg->reglives.assignedpFlows);
 986
 987   }
 988
 989 }
 990
 991 void  pic16_RegsUnMapLiveRanges(void)
 992 {
 993   RegsSetUnMapLiveRanges(pic16_dynAllocRegs);
 994   RegsSetUnMapLiveRanges(pic16_dynStackRegs);
 995   RegsSetUnMapLiveRanges(pic16_dynDirectRegs);
 996   RegsSetUnMapLiveRanges(pic16_dynProcessorRegs);
 997   RegsSetUnMapLiveRanges(pic16_dynDirectBitRegs);
 998   RegsSetUnMapLiveRanges(pic16_dynInternalRegs);
 999 }