git.gag.com Git - fw/sdcc/blob - src/mcs51/peeph.def

   1 //replace restart {
   2 //        pop  %1
   3 //        push %1
   4 //} by {
   5 //        ;       Peephole 1     removed pop %1 push %1 (not push pop)
   6 //}
   7
   8 //replace restart {
   9 //        pop  %1
  10 //        mov  %2,%3
  11 //        push %1
  12 //} by {
  13 //        ;       Peephole 2     removed pop %1 push %1 (not push pop)
  14 //        mov  %2,%3
  15 //}
  16
  17 //
  18 // added by Jean Louis VERN for
  19 // his shift stuff
  20 replace {
  21         xch     a,%1
  22         xch     a,%1
  23 } by {
  24         ;       Peephole 2.a    removed redundant xch xch
  25 }
  26
  27 replace {
  28 // saving 2 byte
  29         mov     %1,#0x00
  30         mov     a,#0x00
  31 } by {
  32         ;       Peephole 3.a    changed mov to clr
  33         clr     a
  34         mov     %1,a
  35 }
  36
  37 replace {
  38 // saving 1 byte
  39         mov     %1,#0x00
  40         clr     a
  41 } by {
  42         ;       Peephole 3.b    changed mov to clr
  43         clr     a
  44         mov     %1,a
  45 }
  46
  47 replace {
  48 // saving 1 byte, loosing 1 cycle but maybe allowing peephole 3.b to start
  49         mov     %1,#0x00
  50         mov     %2,#0x00
  51         mov     a,%3
  52 } by {
  53         ;       Peephole 3.c    changed mov to clr
  54         clr     a
  55         mov     %1,a
  56         mov     %2,a
  57         mov     a,%3
  58 }
  59
  60 replace {
  61         mov     %1,a
  62         mov     dptr,#%2
  63         mov     a,%1
  64         movx    @dptr,a
  65 } by {
  66         ;       Peephole 100    removed redundant mov
  67         mov     %1,a
  68         mov     dptr,#%2
  69         movx    @dptr,a
  70 } if notVolatile %1
  71
  72 replace {
  73         mov     a,%1
  74         movx    @dptr,a
  75         inc     dptr
  76         mov     a,%1
  77         movx    @dptr,a
  78 } by {
  79         ;       Peephole 101    removed redundant mov
  80         mov     a,%1
  81         movx    @dptr,a
  82         inc     dptr
  83         movx    @dptr,a
  84 } if notVolatile %1
  85
  86 replace {
  87         mov     %1,%2
  88         ljmp    %3
  89 %4:
  90         mov     %1,%5
  91 %3:
  92         mov     dpl,%1
  93 %7:
  94         mov     sp,bp
  95         pop     bp
  96 } by {
  97         ;       Peephole 102    removed redundant mov
  98         mov     dpl,%2
  99         ljmp    %3
 100 %4:
 101         mov     dpl,%5
 102 %3:
 103 %7:
 104         mov     sp,bp
 105         pop     bp
 106 } if notVolatile %1
 107
 108 replace {
 109         mov     %1,%2
 110         ljmp    %3
 111 %4:
 112         mov     a%1,%5
 113 %3:
 114         mov     dpl,%1
 115 %7:
 116         mov     sp,bp
 117         pop     bp
 118 } by {
 119         ;       Peephole 103    removed redundant mov
 120         mov     dpl,%2
 121         ljmp    %3
 122 %4:
 123         mov     dpl,%5
 124 %3:
 125 %7:
 126         mov     sp,bp
 127         pop     bp
 128 }
 129
 130 replace {
 131         mov     a,bp
 132         clr     c
 133         add     a,#0x01
 134         mov     r%1,a
 135 } by {
 136         ;       Peephole 104    optimized increment (acc not set to r%1, flags undefined)
 137         mov     r%1,bp
 138         inc     r%1
 139 }
 140
 141 replace {
 142         mov     %1,a
 143         mov     a,%1
 144 } by {
 145         ;       Peephole 105    removed redundant mov
 146         mov     %1,a
 147 } if notVolatile %1
 148
 149 replace {
 150         mov     %1,a
 151         clr     c
 152         mov     a,%1
 153 } by {
 154         ;       Peephole 106    removed redundant mov
 155         mov     %1,a
 156         clr     c
 157 } if notVolatile %1
 158
 159 replace {
 160         ljmp    %1
 161 %1:
 162 } by {
 163         ;       Peephole 107    removed redundant ljmp
 164 %1:
 165 }
 166
 167 replace {
 168         jc      %1
 169         ljmp    %5
 170 %1:
 171 } by {
 172         ;       Peephole 108    removed ljmp by inverse jump logic
 173         jnc     %5
 174 %1:
 175 } if labelInRange
 176
 177 replace {
 178         jz      %1
 179         ljmp    %5
 180 %1:
 181 } by {
 182         ;       Peephole 109    removed ljmp by inverse jump logic
 183         jnz     %5
 184 %1:
 185 } if labelInRange
 186
 187 replace {
 188         jnz     %1
 189         ljmp    %5
 190 %1:
 191 } by {
 192         ;       Peephole 110    removed ljmp by inverse jump logic
 193         jz      %5
 194 %1:
 195 } if labelInRange
 196
 197 replace {
 198         jb      %1,%2
 199         ljmp    %5
 200 %2:
 201 } by {
 202         ;       Peephole 111    removed ljmp by inverse jump logic
 203         jnb     %1,%5
 204 %2:
 205 } if labelInRange
 206
 207 replace {
 208         jnb     %1,%2
 209         ljmp    %5
 210 %2:
 211 } by {
 212         ;       Peephole 112.a  removed ljmp by inverse jump logic
 213         jb      %1,%5
 214 %2:
 215 } if labelInRange
 216
 217 replace {
 218         ljmp    %5
 219 %1:
 220 } by {
 221         ;       Peephole 112.b  changed ljmp to sjmp
 222         sjmp    %5
 223 %1:
 224 } if labelInRange
 225
 226
 227 replace {
 228         clr     a
 229         cjne    %1,%2,%3
 230         cpl     a
 231 %3:
 232         rrc     a
 233         mov     %4,c
 234 } by {
 235         ;       Peephole 113    optimized misc sequence
 236         clr     %4
 237         cjne    %1,%2,%3
 238         setb    %4
 239 %3:
 240 } if labelRefCount %3 1
 241
 242 replace {
 243         clr     a
 244         cjne    %1,%2,%3
 245         cjne    %10,%11,%3
 246         cpl     a
 247 %3:
 248         rrc     a
 249         mov     %4,c
 250 } by {
 251         ;       Peephole 114    optimized misc sequence
 252         clr     %4
 253         cjne    %1,%2,%3
 254         cjne    %10,%11,%3
 255         setb    %4
 256 %3:
 257 } if labelRefCount %3 2
 258
 259 replace {
 260         clr     a
 261         cjne    %1,%2,%3
 262         cpl     a
 263 %3:
 264         jnz     %4
 265 } by {
 266         ;       Peephole 115    jump optimization
 267         cjne    %1,%2,%3
 268         sjmp    %4
 269 %3:
 270 } if labelRefCount %3 1
 271
 272 replace {
 273         clr     a
 274         cjne    %1,%2,%3
 275         cjne    %9,%10,%3
 276         cpl     a
 277 %3:
 278         jnz     %4
 279 } by {
 280         ;       Peephole 116    jump optimization
 281         cjne    %1,%2,%3
 282         cjne    %9,%10,%3
 283         sjmp    %4
 284 %3:
 285 } if labelRefCount %3 2
 286
 287 replace {
 288         clr     a
 289         cjne    %1,%2,%3
 290         cjne    %9,%10,%3
 291         cjne    %11,%12,%3
 292         cpl     a
 293 %3:
 294         jnz %4
 295 } by {
 296         ;       Peephole 117    jump optimization
 297         cjne    %1,%2,%3
 298         cjne    %9,%10,%3
 299         cjne    %11,%12,%3
 300         sjmp    %4
 301 %3:
 302 } if labelRefCount %3 3
 303
 304 replace {
 305         clr     a
 306         cjne    %1,%2,%3
 307         cjne    %9,%10,%3
 308         cjne    %11,%12,%3
 309         cjne    %13,%14,%3
 310         cpl     a
 311 %3:
 312         jnz     %4
 313 } by {
 314         ;       Peephole 118    jump optimization
 315         cjne    %1,%2,%3
 316         cjne    %9,%10,%3
 317         cjne    %11,%12,%3
 318         cjne    %13,%14,%3
 319         sjmp    %4
 320 %3:
 321 } if labelRefCount %3 4
 322
 323 replace {
 324         mov     a,#0x01
 325         cjne    %1,%2,%3
 326         clr     a
 327 %3:
 328         jnz     %4
 329 } by {
 330         ;       Peephole 119    jump optimization
 331         cjne    %1,%2,%4
 332 %3:
 333 } if labelRefCount %3 1
 334
 335 replace {
 336         mov     a,#0x01
 337         cjne    %1,%2,%3
 338         cjne    %10,%11,%3
 339         clr     a
 340 %3:
 341         jnz     %4
 342 } by {
 343         ;       Peephole 120    jump optimization
 344         cjne    %1,%2,%4
 345         cjne    %10,%11,%4
 346 %3:
 347 } if labelRefCount %3 2
 348
 349 replace {
 350         mov     a,#0x01
 351         cjne    %1,%2,%3
 352         cjne    %10,%11,%3
 353         cjne    %12,%13,%3
 354         clr     a
 355 %3:
 356         jnz  %4
 357 } by {
 358         ;       Peephole 121    jump optimization
 359         cjne    %1,%2,%4
 360         cjne    %10,%11,%4
 361         cjne    %12,%13,%4
 362 %3:
 363 } if labelRefCount %3 3
 364
 365 replace {
 366         mov     a,#0x01
 367         cjne    %1,%2,%3
 368         cjne    %10,%11,%3
 369         cjne    %12,%13,%3
 370         cjne    %14,%15,%3
 371         clr     a
 372 %3:
 373         jnz     %4
 374 } by {
 375         ;       Peephole 122    jump optimization
 376         cjne    %1,%2,%4
 377         cjne    %10,%11,%4
 378         cjne    %12,%13,%4
 379         cjne    %14,%15,%4
 380 %3:
 381 } if labelRefCount %3 4
 382
 383 replace {
 384         mov     a,#0x01
 385         cjne    %1,%2,%3
 386         clr     a
 387 %3:
 388         jz      %4
 389 } by {
 390         ;       Peephole 123    jump optimization
 391         cjne    %1,%2,%3
 392         smp     %4
 393 %3:
 394 } if labelRefCount %3 1
 395
 396 replace {
 397         mov     a,#0x01
 398         cjne    %1,%2,%3
 399         cjne    %10,%11,%3
 400         clr     a
 401 %3:
 402         jz      %4
 403 } by {
 404         ;       Peephole 124    jump optimization
 405         cjne    %1,%2,%3
 406         cjne    %10,%11,%3
 407         sjmp    %4
 408 %3:
 409 } if labelRefCount %3 2
 410
 411 replace {
 412         mov     a,#0x01
 413         cjne    %1,%2,%3
 414         cjne    %10,%11,%3
 415         cjne    %12,%13,%3
 416         clr     a
 417 %3:
 418         jz      %4
 419 } by {
 420         ;       Peephole 125    jump optimization
 421         cjne    %1,%2,%3
 422         cjne    %10,%11,%3
 423         cjne    %12,%13,%3
 424         sjmp    %4
 425 %3:
 426 } if labelRefCount %3 3
 427
 428 replace {
 429         mov     a,#0x01
 430         cjne    %1,%2,%3
 431         cjne    %10,%11,%3
 432         cjne    %12,%13,%3
 433         cjne    %14,%15,%3
 434         clr     a
 435 %3:
 436         jz      %4
 437 } by {
 438         ;       Peephole 126    jump optimization
 439         cjne    %1,%2,%3
 440         cjne    %10,%11,%3
 441         cjne    %12,%13,%3
 442         cjne    %14,%15,%3
 443         sjmp    %4
 444 %3:
 445 } if labelRefCount %3 4
 446
 447 replace {
 448         push    psw
 449         mov     psw,%1
 450         push    bp
 451         mov     bp,%2
 452 %3:
 453         mov     %2,bp
 454         pop     bp
 455         pop     psw
 456         ret
 457 } by {
 458         ;       Peephole 127    removed misc sequence
 459         ret
 460 } if labelRefCount %3 0
 461
 462 replace {
 463         clr     a
 464         rlc     a
 465         jz      %1
 466 } by {
 467         ;       Peephole 128    jump optimization
 468         jnc     %1
 469 }
 470
 471 replace {
 472         clr     a
 473         rlc     a
 474         jnz     %1
 475 } by {
 476         ;       Peephole 129    jump optimization
 477         jc      %1
 478 }
 479
 480 replace {
 481         mov     r%1,@r%2
 482 } by {
 483         ;       Peephole 130    changed target address mode r%1 to ar%1
 484         mov     ar%1,@r%2
 485 }
 486
 487 replace {
 488         mov     a,%1
 489         subb    a,#0x01
 490         mov     %2,a
 491         mov     %1,%2
 492 } by {
 493         ;       Peephole 131    optimized decrement (not caring for c)
 494         dec     %1
 495         mov     %2,%1
 496 }
 497
 498 replace {
 499         mov     r%1,%2
 500         mov     ar%3,@r%1
 501         inc     r%3
 502         mov     r%4,%2
 503         mov     @r%4,ar%3
 504 } by {
 505         ;       Peephole 133    removed redundant moves
 506         mov     r%1,%2
 507         inc     @r%1
 508         mov     ar%3,@r%1
 509 } if notVolatile
 510
 511 replace {
 512         mov     r%1,%2
 513         mov     ar%3,@r%1
 514         dec     r%3
 515         mov     r%4,%2
 516         mov     @r%4,ar%3
 517 } by {
 518         ;       Peephole 134    removed redundant moves
 519         mov     r%1,%2
 520         dec     @r%1
 521         mov     ar%3,@r%1
 522 } if notVolatile
 523
 524 replace {
 525         mov     r%1,a
 526         mov     a,r%2
 527         orl     a,r%1
 528 } by {
 529         ;       Peephole 135    removed redundant mov
 530         mov     r%1,a
 531         orl     a,r%2
 532 }
 533
 534 replace {
 535         mov     %1,a
 536         mov     dpl,%2
 537         mov     dph,%3
 538         mov     a,%1
 539 } by {
 540         ;       Peephole 136    removed redundant moves
 541         mov     %1,a
 542         mov     dpl,%2
 543         mov     dph,%3
 544 } if notVolatile %1
 545
 546 // WTF? Doesn't look sensible to me...
 547 //replace {
 548 //        mov  b,#0x00
 549 //        mov  a,%1
 550 //        cjne %2,%3,%4
 551 //        mov  b,#0x01
 552 //%4:
 553 //        mov  a,b
 554 //        jz   %5
 555 //} by {
 556 //        ;       Peephole 137   optimized misc jump sequence
 557 //        mov  a,%1
 558 //        cjne %2,%3,%5
 559 //%4:
 560 //} if labelRefCount %4 1
 561 //
 562 //replace {
 563 //        mov  b,#0x00
 564 //        mov  a,%1
 565 //        cjne %2,%3,%4
 566 //        mov  b,#0x01
 567 //%4:
 568 //        mov  a,b
 569 //        jnz  %5
 570 //} by {
 571 //        ;       Peephole 138   optimized misc jump sequence
 572 //        mov  a,%1
 573 //        cjne %2,%3,%4
 574 //        sjmp %5
 575 //%4:
 576 //} if labelRefCount %4 1
 577
 578 replace {
 579         mov     r%1,a
 580         anl     ar%1,%2
 581         mov     a,r%1
 582 } by {
 583         ;       Peephole 139    removed redundant mov
 584         anl     a,%2
 585         mov     r%1,a
 586 }
 587
 588 replace {
 589         mov     r%1,a
 590         orl     ar%1,%2
 591         mov     a,r%1
 592 } by {
 593         ;       Peephole 140    removed redundant mov
 594         orl     a,%2
 595         mov     r%1,a }
 596
 597 replace {
 598         mov     r%1,a
 599         xrl     ar%1,%2
 600         mov     a,r%1
 601 } by {
 602         ;       Peephole 141    removed redundant mov
 603         xrl     a,%2
 604         mov     r%1,a
 605 }
 606
 607 replace {
 608         mov     r%1,a
 609         mov     r%2,ar%1
 610         mov     ar%1,@r%2
 611 } by {
 612         ;       Peephole 142    removed redundant moves
 613         mov     r%2,a
 614         mov     ar%1,@r%2
 615 }
 616
 617 replace {
 618         rlc     a
 619         mov     acc.0,c
 620 } by {
 621         ;       Peephole 143    converted rlc to rl
 622         rl      a
 623 }
 624
 625 replace {
 626         rrc     a
 627         mov     acc.7,c
 628 } by {
 629         ;       Peephole 144    converted rrc to rc
 630         rr      a
 631 }
 632
 633 replace {
 634         clr     c
 635         addc    a,%1
 636 } by {
 637         ;       Peephole 145    changed to add without carry
 638         add     a,%1
 639 }
 640
 641 replace {
 642         clr     c
 643         mov     a,%1
 644         addc    a,%2
 645 } by {
 646         ;       Peephole 146    changed to add without carry
 647         mov     a,%1
 648         add     a,%2
 649 }
 650
 651 replace {
 652         orl     r%1,a
 653 } by {
 654         ;       Peephole 147    changed target address mode r%1 to ar%1
 655         orl     ar%1,a
 656 }
 657
 658 replace {
 659         anl     r%1,a
 660 } by {
 661         ;       Peephole 148    changed target address mode r%1 to ar%1
 662         anl     ar%1,a
 663 }
 664
 665 replace {
 666         xrl     r%1,a
 667 } by {
 668         ;       Peephole 149    changed target address mode r%1 to ar%1
 669         xrl     ar%1,a
 670 }
 671
 672 replace {
 673         mov     r%1,dpl
 674         mov     dpl,r%1
 675 %9:
 676         ret
 677 } by {
 678         ;       Peephole 150    removed misc moves via dpl before return
 679 %9:
 680         ret
 681 }
 682
 683 replace {
 684         mov     r%1,dpl
 685         mov     r%2,dph
 686         mov     dpl,r%1
 687         mov     dph,r%2
 688 %9:
 689         ret
 690 } by {
 691         ;       Peephole 151    removed misc moves via dph, dpl before return
 692 %9:
 693         ret
 694 }
 695
 696 replace {
 697         mov     r%1,dpl
 698         mov     r%2,dph
 699         mov     dpl,r%1
 700 %9:
 701         ret
 702 } by {
 703         ;       Peephole 152    removed misc moves via dph, dpl before return
 704 %9:
 705         ret
 706 }
 707
 708 replace {
 709         mov     r%1,dpl
 710         mov     r%2,dph
 711         mov     r%3,b
 712         mov     dpl,r%1
 713         mov     dph,r%2
 714         mov     b,r%3
 715 %9:
 716         ret
 717 } by {
 718         ;       Peephole 153    removed misc moves via dph, dpl, b before return
 719 %9:
 720         ret
 721 }
 722
 723 replace {
 724         mov     r%1,dpl
 725         mov     r%2,dph
 726         mov     r%3,b
 727         mov     dpl,r%1
 728 %9:
 729         ret
 730 } by {
 731         ;       Peephole 154    removed misc moves via dph, dpl, b before return
 732 %9:
 733         ret
 734 }
 735
 736 replace {
 737         mov     r%1,dpl
 738         mov     r%2,dph
 739         mov     r%3,b
 740         mov     dpl,r%1
 741         mov     dph,r%2
 742 %9:
 743         ret
 744 } by {
 745         ;       Peephole 155    removed misc moves via dph, dpl, b before return
 746 %9:
 747         ret
 748 }
 749
 750 replace {
 751         mov     r%1,dpl
 752         mov     r%2,dph
 753         mov     r%3,b
 754         mov     r%4,a
 755         mov     dpl,r%1
 756         mov     dph,r%2
 757         mov     b,r%3
 758         mov     a,r%4
 759 %9:
 760         ret
 761 } by {
 762         ;       Peephole 156    removed misc moves via dph, dpl, b, a before return
 763 %9:
 764         ret
 765 }
 766
 767 replace {
 768         mov     r%1,dpl
 769         mov     r%2,dph
 770         mov     r%3,b
 771         mov     r%4,a
 772         mov     dpl,r%1
 773         mov     dph,r%2
 774 %9:
 775         ret
 776 } by {
 777         ;       Peephole 157    removed misc moves via dph, dpl, b, a before return
 778 %9:
 779         ret
 780 }
 781
 782 replace {
 783         mov     r%1,dpl
 784         mov     r%2,dph
 785         mov     r%3,b
 786         mov     r%4,a
 787         mov     dpl,r%1
 788 %9:
 789         ret
 790 } by {
 791         ;       Peephole 158    removed misc moves via dph, dpl, b, a before return
 792 %9:
 793         ret
 794 }
 795
 796 replace {
 797         mov     %1,#%2
 798         xrl     %1,#0x80
 799 } by {
 800         ;       Peephole 159    avoided xrl during execution
 801         mov  %1,#(%2 ^ 0x80)
 802 }
 803
 804 replace {
 805         jnc     %1
 806         sjmp    %2
 807 %1:
 808 } by {
 809         ;       Peephole 160    removed sjmp by inverse jump logic
 810         jc      %2
 811 %1:
 812 }
 813
 814 replace {
 815         jc      %1
 816         sjmp    %2
 817 %1:
 818 } by {
 819         ;       Peephole 161    removed sjmp by inverse jump logic
 820         jnc     %2
 821 %1:
 822 }
 823
 824 replace {
 825         jnz     %1
 826         sjmp    %2
 827 %1:
 828 } by {
 829         ;       Peephole 162    removed sjmp by inverse jump logic
 830         jz      %2
 831 %1:
 832 }
 833
 834 replace {
 835         jz      %1
 836         sjmp    %2
 837 %1:
 838 } by {
 839         ;       Peephole 163    removed sjmp by inverse jump logic
 840         jnz     %2
 841 %1:
 842 }
 843
 844 replace {
 845         jnb     %3,%1
 846         sjmp    %2
 847 %1:
 848 } by {
 849         ;       Peephole 164    removed sjmp by inverse jump logic
 850         jb      %3,%2
 851 %1:
 852 }
 853
 854 replace {
 855         jb      %3,%1
 856         sjmp    %2
 857 %1:
 858 } by {
 859         ;       Peephole 165    removed sjmp by inverse jump logic
 860         jnb     %3,%2
 861 %1:
 862 }
 863
 864 replace {
 865         mov     %1,%2
 866         mov     %3,%1
 867         mov     %2,%1
 868 } by {
 869         ;       Peephole 166    removed redundant mov
 870         mov     %1,%2
 871         mov     %3,%1
 872 } if notVolatile %1 %2
 873
 874 replace {
 875         mov     c,%1
 876         cpl     c
 877         mov     %1,c
 878 } by {
 879         ;       Peephole 167    removed redundant bit moves (c not set to %1)
 880         cpl     %1
 881 }
 882
 883 replace {
 884         jnb     %1,%2
 885         sjmp    %3
 886 %2:
 887 } by {
 888         ;       Peephole 168    jump optimization
 889         jb      %1,%3
 890 %2:
 891 }
 892
 893 replace {
 894         jb      %1,%2
 895         sjmp    %3
 896 %2:
 897 } by {
 898         ;       Peephole 169    jump optimization
 899         jnb     %1,%3
 900 %2:
 901 }
 902
 903 replace {
 904         clr     a
 905         cjne    %1,%2,%3
 906         cpl     a
 907 %3:
 908         jz      %4
 909 } by {
 910         ;       Peephole 170    jump optimization
 911         cjne    %1,%2,%4
 912 %3:
 913 } if labelRefCount %3 1
 914
 915 replace {
 916         clr     a
 917         cjne    %1,%2,%3
 918         cjne    %9,%10,%3
 919         cpl     a
 920 %3:
 921         jz      %4
 922 } by {
 923         ;       Peephole 171    jump optimization
 924         cjne    %1,%2,%4
 925         cjne    %9,%10,%4
 926 %3:
 927 } if labelRefCount %3 2
 928
 929 replace {
 930         clr     a
 931         cjne    %1,%2,%3
 932         cjne    %9,%10,%3
 933         cjne    %11,%12,%3
 934         cpl     a
 935 %3:
 936         jz      %4
 937 } by {
 938         ;       Peephole 172    jump optimization
 939         cjne    %1,%2,%4
 940         cjne    %9,%10,%4
 941         cjne    %11,%12,%4
 942 %3:
 943 } if labelRefCount %3 3
 944
 945 replace {
 946         clr     a
 947         cjne    %1,%2,%3
 948         cjne    %9,%10,%3
 949         cjne    %11,%12,%3
 950         cjne    %13,%14,%3
 951         cpl     a
 952 %3:
 953         jz      %4
 954 } by {
 955         ;       Peephole 173    jump optimization
 956         cjne    %1,%2,%4
 957         cjne    %9,%10,%4
 958         cjne    %11,%12,%4
 959         cjne    %13,%14,%4
 960 %3:
 961 } if labelRefCount %3 4
 962
 963 replace {
 964         mov     r%1,%2
 965         clr     c
 966         mov     a,r%1
 967         subb    a,#0x01
 968         mov     %2,a
 969 } by {
 970         ;       Peephole 174    optimized decrement (acc not set to %2, flags undefined)
 971         mov     r%1,%2
 972         dec     %2
 973 }
 974
 975 replace {
 976         mov     r%1,%2
 977         mov     a,r%1
 978         add     a,#0x01
 979         mov     %2,a
 980 } by {
 981         ;       Peephole 175    optimized increment (acc not set to %2, flags undefined)
 982         mov     r%1,%2
 983         inc     %2
 984 }
 985
 986 replace {
 987         mov     %1,@r%2
 988         inc     %1
 989         mov     @r%2,%1
 990 } by {
 991         ;       Peephole 176    optimized increment, removed redundant mov
 992         inc     @r%2
 993         mov     %1,@r%2
 994 } if notVolatile
 995
 996 // this one will screw assignes to volatile/sfr's
 997 replace {
 998         mov  %1,%2
 999         mov  %2,%1
1000 } by {
1001         ;       Peephole 177.a  removed redundant mov
1002         mov  %1,%2
1003 } if notVolatile %1 %2
1004
1005 // applies to f.e. scott-add.asm (--model-large)
1006 replace {
1007         mov     r%1,a
1008         mov     a,ar%1
1009 } by {
1010         ;       Peephole 177.b  removed redundant mov
1011         mov     r%1,a
1012 }
1013
1014 // applies to f.e. bug-408972.c
1015 replace {
1016         mov     %1,%2
1017         mov     %1,%3
1018 } by {
1019         ;       Peephole 177.c  removed redundant move
1020         mov     %1,%3
1021 } if notVolatile %1 %2
1022
1023 // applies to f.e. bug-408972.c
1024 // not before peephole 177.c
1025 replace {
1026         mov     %1,%2
1027         mov     %3,%4
1028         mov     %2,%1
1029 } by {
1030         ;       Peephole 177.d  removed redundant move
1031         mov     %1,%2
1032         mov     %3,%4
1033 } if notVolatile %1 %2
1034
1035 // applies to f.e. bug-607243.c
1036 // also check notVolatile %3, as it will return FALSE if it's @r%1
1037 replace {
1038         mov     r%1,%2
1039         mov     ar%1,%3
1040 } by {
1041         ;       peephole 177.e  removed redundant move
1042         mov     ar%1,%3
1043 } if notVolatile %2 %3
1044
1045 replace {
1046         mov     ar%1,%2
1047         mov     r%1,%3
1048 } by {
1049         ;       peephole 177.f  removed redundant move
1050         mov     r%1,%3
1051 } if notVolatile %2
1052
1053 replace {
1054         mov     a,%1
1055         mov     b,a
1056         mov     a,%2
1057 } by {
1058         ;       Peephole 178    removed redundant mov
1059         mov     b,%1
1060         mov     a,%2
1061 }
1062
1063 // rules 179-182 provided by : Frieder <fe@lake.iup.uni-heidelberg.de>
1064 // saving 2 byte, 1 cycle
1065 replace {
1066         mov     b,#0x00
1067         mov     a,#0x00
1068 } by {
1069         ;       Peephole 179    changed mov to clr
1070         clr     a
1071         mov     b,a
1072 }
1073
1074 // applies to:
1075 // volatile xdata char t; t=0x01; t=0x03;
1076 replace {
1077         mov     dptr,%1
1078         mov     a,%2
1079         movx    @dptr,a
1080         mov     dptr,%1
1081 } by {
1082         ;       Peephole 180.a  removed redundant mov to dptr
1083         mov     dptr,%1
1084         mov     a,%2
1085         movx    @dptr,a
1086 }
1087
1088 // volatile xdata char t; t=0x01; t=0x03; t=0x01;
1089 replace {
1090         mov     dptr,%1
1091         mov     a,%2
1092         movx    @dptr,a
1093         mov     a,%3
1094         movx    @dptr,a
1095         mov     dptr,%1
1096 } by {
1097         ;       Peephole 180.b  removed redundant mov to dptr
1098         mov     dptr,%1
1099         mov     a,%2
1100         movx    @dptr,a
1101         mov     a,%3
1102         movx    @dptr,a
1103 }
1104
1105 // saving 1 byte, 0 cycles
1106 replace {
1107         mov     a,#0x00
1108 } by {
1109         ;       Peephole 181    changed mov to clr
1110         clr     a
1111 }
1112
1113 // saving 3 bytes, 2 cycles
1114 // provided by Bernhard Held <bernhard.held@de.westinghouse.com>
1115 replace {
1116         mov     dpl,#%1
1117         mov     dph,#(%1 >> 8)
1118 } by {
1119         ;       Peephole 182.a  used 16 bit load of DPTR
1120         mov     dptr,#%1
1121 }
1122
1123 // saving 3 byte, 2 cycles, return(NULL) profits here
1124 replace {
1125         mov     dpl,#0x%1
1126         mov     dph,#0x%2
1127 } by {
1128         ;       Peephole 182.b  used 16 bit load of dptr
1129         mov     dptr,#0x%2%1
1130 }
1131
1132 // saving 3 byte, 2 cycles. Probably obsoleted by 182.b
1133 replace {
1134         mov     dpl,#%1
1135         mov     dph,#%2
1136 } by {
1137         ;       Peephole 182.c  used 16 bit load of dptr
1138         mov     dptr,#(((%2)<<8) + %1)
1139 }
1140
1141 // applies to return 0.0; in f.e. sincosf.c
1142 replace {
1143         mov     dpl,#%1
1144         clr     a
1145         mov     dph,a
1146 } by {
1147         ;       Peephole 182.d  used 16 bit load of dptr
1148         mov     dptr,#(%1&0x00ff)
1149         clr     a
1150 }
1151
1152 replace {
1153         anl     %1,#%2
1154         anl     %1,#%3
1155 } by {
1156         ;       Peephole 183    avoided anl during execution
1157         anl     %1,#(%2 & %3)
1158 }
1159
1160 replace {
1161         mov     %1,a
1162         cpl     a
1163         mov     %1,a
1164 } by {
1165         ;       Peephole 184    removed redundant mov
1166         cpl     a
1167         mov     %1,a
1168 } if notVolatile %1
1169
1170 replace {
1171 // acc being incremented might cause problems
1172         mov     %1,a
1173         inc     %1
1174 } by {
1175         ;       Peephole 185    changed order of increment (acc incremented also!)
1176         inc     a
1177         mov     %1,a
1178 } if notVolatile %1
1179
1180 replace {
1181         add     a,#%1
1182         mov     dpl,a
1183         clr     a
1184         addc    a,#(%1 >> 8)
1185         mov     dph,a
1186         clr     a
1187         movc    a,@a+dptr
1188         mov     %2,a
1189         inc     dptr
1190         clr     a
1191         movc    a,@a+dptr
1192         mov     %3,a
1193         inc     dptr
1194         clr     a
1195         movc    a,@a+dptr
1196         mov     %4,a
1197         inc     dptr
1198         clr     a
1199 } by {
1200         ;       Peephole 186.a  optimized movc sequence
1201         mov     dptr,#%1
1202         mov     b,acc
1203         movc    a,@a+dptr
1204         mov     %2,a
1205         mov     acc,b
1206         inc     dptr
1207         movc    a,@a+dptr
1208         mov     %3,a
1209         mov     acc,b
1210         inc     dptr
1211         movc    a,@a+dptr
1212         mov     %4,a
1213         mov     acc,b
1214         inc     dptr
1215 }
1216
1217 replace {
1218         add     a,#%1
1219         mov     dpl,a
1220         clr     a
1221         addc    a,#(%1 >> 8)
1222         mov     dph,a
1223         clr     a
1224         movc    a,@a+dptr
1225         mov     %2,a
1226         inc     dptr
1227         clr     a
1228         movc    a,@a+dptr
1229         mov     %3,a
1230         inc     dptr
1231         clr     a
1232 } by {
1233         ;       Peephole 186.b  optimized movc sequence
1234         mov     dptr,#%1
1235         mov     b,acc
1236         movc    a,@a+dptr
1237         mov     %2,a
1238         mov     acc,b
1239         inc     dptr
1240         movc    a,@a+dptr
1241         mov     %3,a
1242         mov     acc,b
1243         inc     dptr
1244 }
1245
1246 replace {
1247         add     a,#%1
1248         mov     dpl,a
1249         clr     a
1250         addc    a,#(%1 >> 8)
1251         mov     dph,a
1252         clr     a
1253         movc    a,@a+dptr
1254         mov     %2,a
1255         inc     dptr
1256         clr     a
1257 } by {
1258         ;       Peephole 186.c  optimized movc sequence
1259         mov     dptr,#%1
1260         mov     b,acc
1261         movc    a,@a+dptr
1262         mov     %2,a
1263         mov     acc,b
1264         inc     dptr
1265 }
1266
1267 // char indexed access to: char code table[] = {4,3,2,1};
1268 replace {
1269         add     a,#%1
1270         mov     dpl,a
1271         clr     a
1272         addc    a,#(%1 >> 8)
1273         mov     dph,a
1274         clr     a
1275         movc    a,@a+dptr
1276 } by {
1277         ;       Peephole 186.d  optimized movc sequence
1278         mov     dptr,#%1
1279         movc    a,@a+dptr
1280 }
1281
1282 // char indexed access to: int code table[] = {4,3,2,1};
1283 replace {
1284         mov     b,#0x02
1285         mul     ab
1286         add     a,#%2
1287         mov     dpl,a
1288         mov     a,b
1289         addc    a,#(%2 >> 8)
1290         mov     dph,a
1291         clr     a
1292         movc    a,@a+dptr
1293         mov     %3,a
1294         mov     a,#0x01
1295         movc    a,@a+dptr
1296 } by {
1297         ;       Peephole 186.e  optimized movc sequence (b, dptr differ)
1298         add     a,acc
1299         mov     b,a
1300         mov     dptr,#%2
1301         jnc     .+3
1302         inc     dph
1303         movc    a,@a+dptr
1304         mov     %3,a
1305         mov     a,b
1306         inc     a
1307         movc    a,@a+dptr
1308 }
1309
1310 replace {
1311         mov     r%1,%2
1312         anl     ar%1,#%3
1313         mov     a,r%1
1314 } by {
1315         ;       Peephole 187    used a instead of ar%1 for anl
1316         mov     a,%2
1317         anl     a,#%3
1318         mov     r%1,a
1319 }
1320
1321 replace {
1322         mov     %1,a
1323         mov     dptr,%2
1324         movc    a,@a+dptr
1325         mov     %1,a
1326 } by {
1327         ;       Peephole 188    removed redundant mov
1328         mov     dptr,%2
1329         movc    a,@a+dptr
1330         mov     %1,a
1331 } if notVolatile %1
1332
1333 replace {
1334         anl     a,#0x0f
1335         mov     %1,a
1336         mov     a,#0x0f
1337         anl     a,%1
1338 } by {
1339         ;       Peephole 189    removed redundant mov and anl
1340         anl     a,#0x0f
1341         mov     %1,a
1342 } if notVolatile %1
1343
1344 // rules 190 & 191 need to be in order
1345 replace {
1346         mov     a,%1
1347         lcall   __gptrput
1348         mov     a,%1
1349 } by {
1350         ;       Peephole 190    removed redundant mov
1351         mov     a,%1
1352         lcall   __gptrput
1353 } if notVolatile %1
1354
1355 replace {
1356         mov     %1,a
1357         mov     dpl,%2
1358         mov     dph,%3
1359         mov     b,%4
1360         mov     a,%1
1361 } by {
1362         ;       Peephole 191    removed redundant mov
1363         mov     %1,a
1364         mov     dpl,%2
1365         mov     dph,%3
1366         mov     b,%4
1367 } if notVolatile %1
1368
1369 replace {
1370         mov     r%1,a
1371         mov     @r%2,ar%1
1372 } by {
1373         ;       Peephole 192    used a instead of ar%1 as source
1374         mov     r%1,a
1375         mov     @r%2,a
1376 }
1377
1378 replace {
1379         jnz     %3
1380         mov     a,%4
1381         jnz     %3
1382         mov     a,%9
1383         jnz     %3
1384         mov     a,%12
1385         cjne    %13,%14,%3
1386         sjmp    %7
1387 %3:
1388         sjmp    %8
1389 } by {
1390         ;       Peephole 193.a  optimized misc jump sequence
1391         jnz     %8
1392         mov     a,%4
1393         jnz     %8
1394         mov     a,%9
1395         jnz     %8
1396         mov     a,%12
1397         cjne    %13,%14,%8
1398         sjmp    %7
1399 ;%3:
1400 } if labelRefCount %3 4
1401
1402 replace {
1403         cjne    %1,%2,%3
1404         mov     a,%4
1405         cjne    %5,%6,%3
1406         mov     a,%9
1407         cjne    %10,%11,%3
1408         mov     a,%12
1409         cjne    %13,%14,%3
1410         sjmp    %7
1411 %3:
1412         sjmp    %8
1413 } by {
1414         ;       Peephole 193.b  optimized misc jump sequence
1415         cjne    %1,%2,%8
1416         mov     a,%4
1417         cjne    %5,%6,%8
1418         mov     a,%9
1419         cjne    %10,%11,%8
1420         mov     a,%12
1421         cjne    %13,%14,%8
1422         sjmp    %7
1423 ;%3:
1424 } if labelRefCount %3 4
1425
1426 replace {
1427         cjne    @%1,%2,%3
1428         inc     %1
1429         cjne    @%1,%6,%3
1430         inc     %1
1431         cjne    @%1,%11,%3
1432         inc     %1
1433         cjne    @%1,%14,%3
1434         sjmp    %7
1435 %3:
1436         sjmp    %8
1437 } by {
1438         ;       Peephole 193.c  optimized misc jump sequence
1439         cjne    @%1,%2,%8
1440         inc     %1
1441         cjne    @%1,%6,%8
1442         inc     %1
1443         cjne    @%1,%11,%8
1444         inc     %1
1445         cjne    @%1,%14,%8
1446         sjmp    %7
1447 ;%3:
1448 } if labelRefCount %3 4
1449
1450 replace {
1451         cjne    %1,%2,%3
1452         cjne    %5,%6,%3
1453         cjne    %10,%11,%3
1454         cjne    %13,%14,%3
1455         sjmp    %7
1456 %3:
1457         sjmp    %8
1458 } by {
1459         ;       Peephole 194    optimized misc jump sequence
1460         cjne    %1,%2,%8
1461         cjne    %5,%6,%8
1462         cjne    %10,%11,%8
1463         cjne    %13,%14,%8
1464         sjmp    %7
1465 ;%3:
1466 } if labelRefCount %3 4
1467
1468 replace {
1469         jnz     %3
1470         mov     a,%4
1471         jnz     %3
1472         mov     a,%9
1473         cjne    %10,%11,%3
1474         sjmp    %7
1475 %3:
1476         sjmp    %8
1477 } by {
1478         ;       Peephole 195.a  optimized misc jump sequence
1479         jnz     %8
1480         mov     a,%4
1481         jnz     %8
1482         mov     a,%9
1483         cjne    %10,%11,%8
1484         sjmp    %7
1485 ;%3:
1486 } if labelRefCount %3 3
1487
1488 replace {
1489         cjne    %1,%2,%3
1490         mov     a,%4
1491         cjne    %5,%6,%3
1492         mov     a,%9
1493         cjne    %10,%11,%3
1494         sjmp    %7
1495 %3:
1496         sjmp    %8
1497 } by {
1498         ;       Peephole 195.b  optimized misc jump sequence
1499         cjne    %1,%2,%8
1500         mov     a,%4
1501         cjne    %5,%6,%8
1502         mov     a,%9
1503         cjne    %10,%11,%8
1504         sjmp    %7
1505 ;%3:
1506 } if labelRefCount %3 3
1507
1508 replace {
1509         cjne    @%1,%2,%3
1510         inc     %1
1511         cjne    @%1,%6,%3
1512         inc     %1
1513         cjne    @%1,%11,%3
1514         sjmp    %7
1515 %3:
1516         sjmp    %8
1517 } by {
1518         ;       Peephole 195.c  optimized misc jump sequence
1519         cjne    @%1,%2,%8
1520         inc     %1
1521         cjne    @%1,%6,%8
1522         inc     %1
1523         cjne    @%1,%11,%8
1524         sjmp    %7
1525 ;%3:
1526 } if labelRefCount %3 3
1527
1528 replace {
1529         cjne    %1,%2,%3
1530         cjne    %5,%6,%3
1531         cjne    %10,%11,%3
1532         sjmp    %7
1533 %3:
1534         sjmp    %8
1535 } by {
1536         ;       Peephole 196    optimized misc jump sequence
1537         cjne    %1,%2,%8
1538         cjne    %5,%6,%8
1539         cjne    %10,%11,%8
1540         sjmp    %7
1541 ;%3:
1542 } if labelRefCount %3 3
1543
1544 replace {
1545         jnz     %3
1546         mov     a,%4
1547         cjne    %5,%6,%3
1548         sjmp    %7
1549 %3:
1550         sjmp    %8
1551 } by {
1552         ;       Peephole 197.a  optimized misc jump sequence
1553         jnz     %8
1554         mov     a,%4
1555         cjne    %5,%6,%8
1556         sjmp    %7
1557 ;%3:
1558 } if labelRefCount %3 2
1559
1560 replace {
1561         cjne    %1,%2,%3
1562         mov     a,%4
1563         cjne    %5,%6,%3
1564         sjmp    %7
1565 %3:
1566         sjmp    %8
1567 } by {
1568         ;       Peephole 197.b  optimized misc jump sequence
1569         cjne    %1,%2,%8
1570         mov     a,%4
1571         cjne    %5,%6,%8
1572         sjmp    %7
1573 ;%3:
1574 } if labelRefCount %3 2
1575
1576 replace {
1577         cjne     @%1,%2,%3
1578         inc     %1
1579         cjne    @%1,%6,%3
1580         sjmp    %7
1581 %3:
1582         sjmp    %8
1583 } by {
1584         ;       Peephole 197.c  optimized misc jump sequence
1585         cjne    @%1,%2,%8
1586         inc     %1
1587         cjne    @%1,%6,%8
1588         sjmp    %7
1589 ;%3:
1590 } if labelRefCount %3 2
1591
1592 replace {
1593         cjne    %1,%2,%3
1594         cjne    %5,%6,%3
1595         sjmp    %7
1596 %3:
1597         sjmp    %8
1598 } by {
1599         ;       Peephole 198    optimized misc jump sequence
1600         cjne    %1,%2,%8
1601         cjne    %5,%6,%8
1602         sjmp    %7
1603 ;%3:
1604 } if labelRefCount %3 2
1605
1606 replace {
1607         cjne    %1,%2,%3
1608         sjmp    %4
1609 %3:
1610         sjmp    %5
1611 } by {
1612         ;       Peephole 199    optimized misc jump sequence
1613         cjne    %1,%2,%5
1614         sjmp    %4
1615 ;%3:
1616 } if labelRefCount %3 1
1617
1618 replace {
1619         sjmp    %1
1620 %1:
1621 } by {
1622         ;       Peephole 200    removed redundant sjmp
1623 %1:
1624 }
1625
1626 replace {
1627         sjmp    %1
1628 %2:
1629 %1:
1630 } by {
1631         ;       Peephole 201    removed redundant sjmp
1632 %2:
1633 %1:
1634 }
1635
1636 replace {
1637         push    acc
1638         mov     dptr,%1
1639         pop     acc
1640 } by {
1641         ;       Peephole 202    removed redundant push pop
1642         mov     dptr,%1
1643 }
1644
1645 replace {
1646         mov     r%1,_spx
1647         lcall   %2
1648         mov     r%1,_spx
1649 } by {
1650         ;       Peephole 203    removed mov  r%1,_spx
1651         lcall   %2
1652 }
1653
1654 replace {
1655         mov     %1,a
1656         add     a,acc
1657         mov     %1,a
1658 } by {
1659         ;       Peephole 204    removed redundant mov
1660         add     a,acc
1661         mov     %1,a
1662 } if notVolatile %1
1663
1664 replace {
1665         djnz    %1,%2
1666         sjmp    %3
1667 %2:
1668         sjmp    %4
1669 %3:
1670 } by {
1671         ;       Peephole 205    optimized misc jump sequence
1672         djnz    %1,%4
1673 %2:
1674 %3:
1675 } if labelRefCount %2 1
1676
1677 replace {
1678         mov     %1,%1
1679 } by {
1680         ;       Peephole 206    removed redundant mov %1,%1
1681 } if notVolatile
1682
1683 replace {
1684         mov     a,_bp
1685         add     a,#0x00
1686         mov     %1,a
1687 } by {
1688         ;       Peephole 207    removed zero add (acc not set to %1, flags undefined)
1689         mov     %1,_bp
1690 }
1691
1692 replace {
1693         push    acc
1694         mov     r%1,_bp
1695         pop     acc
1696 } by {
1697         ;       Peephole 208    removed redundant push pop
1698         mov     r%1,_bp
1699 }
1700
1701 replace {
1702         mov     a,_bp
1703         add     a,#0x00
1704         inc     a
1705         mov     %1,a
1706 } by {
1707         ;       Peephole 209    optimized increment (acc not set to %1, flags undefined)
1708         mov     %1,_bp
1709         inc     %1
1710 }
1711
1712 replace {
1713         mov     dptr,#((((%1 >> 8)) <<8) + %1)
1714 } by {
1715         ;       Peephole 210    simplified expression
1716         mov     dptr,#%1
1717 }
1718
1719 replace {
1720         push    %1
1721         pop     %1
1722 } by {
1723         ;       Peephole 211    removed redundant push %1 pop %1
1724 }
1725
1726 replace {
1727         mov     a,_bp
1728         add     a,#0x01
1729         mov     r%1,a
1730 } by {
1731         ;       Peephole 212    reduced add sequence to inc
1732         mov     r%1,_bp
1733         inc     r%1
1734 }
1735
1736 replace {
1737         mov     %1,#(( %2 >> 8 ) ^ 0x80)
1738 } by {
1739         ;       Peephole 213.a  inserted fix
1740         mov     %1,#(%2 >> 8)
1741         xrl     %1,#0x80
1742 }
1743
1744 replace {
1745         mov     %1,#(( %2 + %3 >> 8 ) ^ 0x80)
1746 } by {
1747         ;       Peephole 213.b  inserted fix
1748         mov     %1,#((%2 + %3) >> 8)
1749         xrl     %1,#0x80
1750 }
1751
1752
1753 replace  {
1754         mov     %1,a
1755         mov     a,%2
1756         add     a,%1
1757 } by {
1758         ;       Peephole 214    reduced some extra moves
1759         mov     %1,a
1760         add     a,%2
1761 } if operandsNotSame
1762
1763 replace {
1764         mov     %1,a
1765         add     a,%2
1766         mov     %1,a
1767 } by {
1768         ;       Peephole 215    removed some moves
1769         add     a,%2
1770         mov     %1,a
1771 } if operandsNotSame
1772
1773 replace {
1774         mov     r%1,%2
1775         clr     a
1776         inc     r%1
1777         mov     @r%1,a
1778         dec     r%1
1779         mov     @r%1,a
1780 } by {
1781         ;       Peephole 216    simplified clear (2bytes)
1782         mov     r%1,%2
1783         clr     a
1784         mov     @r%1,a
1785         inc     r%1
1786         mov     @r%1,a
1787 }
1788
1789 replace {
1790         mov     r%1,%2
1791         clr     a
1792         inc     r%1
1793         inc     r%1
1794         mov     @r%1,a
1795         dec     r%1
1796         mov     @r%1,a
1797         dec     r%1
1798         mov     @r%1,a
1799 } by {
1800         ;       Peephole 217    simplified clear (3bytes)
1801         mov     r%1,%2
1802         clr     a
1803         mov     @r%1,a
1804         inc     r%1
1805         mov     @r%1,a
1806         inc     r%1
1807         mov     @r%1,a
1808 }
1809
1810 replace {
1811         mov     r%1,%2
1812         clr     a
1813         inc     r%1
1814         inc     r%1
1815         inc     r%1
1816         mov     @r%1,a
1817         dec     r%1
1818         mov     @r%1,a
1819         dec     r%1
1820         mov     @r%1,a
1821         dec     r%1
1822         mov     @r%1,a
1823 } by {
1824         ;       Peephole 218    simplified clear (4bytes)
1825         mov     r%1,%2
1826         clr     a
1827         mov     @r%1,a
1828         inc     r%1
1829         mov     @r%1,a
1830         inc     r%1
1831         mov     @r%1,a
1832         inc     r%1
1833         mov     @r%1,a
1834 }
1835
1836 replace {
1837         clr     a
1838         movx    @dptr,a
1839         mov     dptr,%1
1840         clr     a
1841         movx    @dptr,a
1842 } by {
1843         ;       Peephole 219    removed redundant clear
1844         clr     a
1845         movx    @dptr,a
1846         mov     dptr,%1
1847         movx    @dptr,a
1848 }
1849
1850 replace {
1851         clr     a
1852         movx    @dptr,a
1853         mov     dptr,%1
1854         movx    @dptr,a
1855         mov     dptr,%2
1856         clr     a
1857         movx    @dptr,a
1858 } by {
1859         ;       Peephole 219.a  removed redundant clear
1860         clr     a
1861         movx    @dptr,a
1862         mov     dptr,%1
1863         movx    @dptr,a
1864         mov     dptr,%2
1865         movx    @dptr,a
1866 }
1867
1868 replace {
1869         mov     dps,#0x00
1870         mov     dps,#0x01
1871 } by {
1872         ;       Peephole 220.a  removed bogus DPS set
1873         mov     dps,#0x01
1874 }
1875
1876 replace {
1877         mov     dps,#0x01
1878         mov     dps,#0x00
1879 } by {
1880         ;       Peephole 220.b  removed bogus DPS set
1881         mov     dps,#0x00
1882 }
1883
1884 replace {
1885         mov     %1 + %2,(%2 + %1)
1886 } by {
1887         ;       Peephole 221.a  remove redundant move
1888 } if notVolatile
1889
1890 replace {
1891         mov     (%1 + %2 + %3),((%2 + %1) + %3)
1892 } by {
1893         ;       Peephole 221.b  remove redundant move
1894 } if notVolatile
1895
1896 replace {
1897         dec     r%1
1898         inc     r%1
1899 } by {
1900         ;       Peephole 222    removed dec/inc pair
1901 }
1902
1903 replace {
1904         mov     %1,dpl
1905         mov     %2,dph
1906         mov     dpl,%1
1907         mov     dph,%2
1908 } by {
1909         ;       Peephole 223    removed redundant dph/dpl moves
1910         mov     %1,dpl
1911         mov     %2,dph
1912 } if notVolatile %1 %2
1913
1914 replace {
1915         mov     %1,dpl
1916         mov     (%1 + 1),dph
1917         mov     dpl,%1
1918         mov     dph,(%1 + 1)
1919 } by {
1920         ;       Peephole 224    removed redundant dph/dpl moves
1921         mov     %1,dpl
1922         mov     (%1 + 1),dph
1923 } if notVolatile %1
1924
1925 replace {
1926         mov     a,%1
1927         movx    @dptr,a
1928         mov     dpl,%2
1929         mov     dph,%3
1930         mov     b,%4
1931         mov     a,%1
1932 } by {
1933         ;       Peephole 225    removed redundant move to acc
1934         mov     a,%1
1935         movx    @dptr,a
1936         mov     dpl,%2
1937         mov     dph,%3
1938         mov     b,%4
1939 } if notVolatile %1
1940
1941 replace {
1942         clr     a
1943         movx    @dptr,a
1944         inc     dptr
1945         movx    @dptr,a
1946         inc     dptr
1947         clr     a
1948 } by {
1949         ;       Peephole 226    removed unnecessary clr
1950         clr     a
1951         movx    @dptr,a
1952         inc     dptr
1953         movx    @dptr,a
1954         inc     dptr
1955 }
1956
1957 replace {
1958         mov     dptr,#%1
1959         clr     a
1960         inc     dptr
1961         inc     dptr
1962         inc     dptr
1963         movx    @dptr,a
1964         lcall   __decdptr
1965         movx    @dptr,a
1966         lcall   __decdptr
1967         movx    @dptr,a
1968         lcall   __decdptr
1969         movx    @dptr,a
1970 } by {
1971         ;       Peephole 227    replaced inefficient 32 bit clear
1972         mov     dptr,#%1
1973         clr     a
1974         movx    @dptr,a
1975         inc     dptr
1976         movx    @dptr,a
1977         inc     dptr
1978         movx    @dptr,a
1979         inc     dptr
1980         movx    @dptr,a
1981         mov     dptr,#%1
1982 }
1983
1984 replace {
1985         mov     dptr,#%1
1986         clr     a
1987         inc     dptr
1988         inc     dptr
1989         inc     dptr
1990         movx    @dptr,a
1991         lcall   __decdptr
1992         movx    @dptr,a
1993         lcall   __decdptr
1994         movx    @dptr,a
1995         lcall   __decdptr
1996         mov     a,#%2
1997         movx    @dptr,a
1998 } by {
1999         ;       Peephole 228    replaced inefficient 32 constant
2000         mov     dptr,#%1
2001         mov     a,#%2
2002         movx    @dptr,a
2003         inc     dptr
2004         clr     a
2005         movx    @dptr,a
2006         inc     dptr
2007         movx    @dptr,a
2008         inc     dptr
2009         movx    @dptr,a
2010         mov     dptr,#%1
2011 }
2012
2013 replace {
2014         mov     dptr,#%1
2015         clr     a
2016         inc     dptr
2017         movx    @dptr,a
2018         lcall   __decdptr
2019         movx    @dptr,a
2020 } by {
2021         ;       Peephole 229    replaced inefficient 16 bit clear
2022         mov     dptr,#%1
2023         clr     a
2024         movx    @dptr,a
2025         inc     dptr
2026         movx    @dptr,a
2027         mov     dptr,#%1
2028 }
2029
2030 replace {
2031         mov     dptr,#%1
2032         clr     a
2033         inc     dptr
2034         movx    @dptr,a
2035         lcall   __decdptr
2036         mov     a,#%2
2037         movx    @dptr,a
2038 } by {
2039         ;       Peephole 230    replaced inefficient 16 bit constant
2040         mov     dptr,#%1
2041         mov     a,#%2
2042         movx    @dptr,a
2043         inc     dptr
2044         clr     a
2045         movx    @dptr,a
2046         mov     dptr,#%1
2047 }
2048
2049 // this last peephole often removes the last mov from 227-230
2050 replace {
2051         mov     dptr,#%1
2052         mov     dptr,#%2
2053 } by {
2054         ;       Peephole 231    removed redundant mov to dptr
2055         mov     dptr,#%2
2056 }
2057
2058 replace {
2059         movx    a,@dptr
2060 } by {
2061         ;       Peephole 232    using movc to read xdata (--xram-movc)
2062         clr     a
2063         movc    a,@a+dptr
2064 } if xramMovcOption
2065
2066 replace {
2067         lcall   _gptrget
2068 } by {
2069         ;       Peephole 233    using _gptrgetc instead of _gptrget (--xram-movc)
2070         lcall   _gptrgetc
2071 } if xramMovcOption
2072
2073 replace {
2074         mov     r%1,a
2075         mov     dpl,r%1
2076 %2:
2077         ret
2078 } by {
2079         ;       Peephole 234    loading dpl directly from a(ccumulator), r%1 not set
2080         mov     dpl,a
2081 %2:
2082         ret
2083 }
2084
2085 replace {
2086         mov     r%1,a
2087         mov     dpl,r%2
2088         mov     dph,r%1
2089 %3:
2090         ret
2091 } by {
2092         ;       Peephole 235    loading dph directly from a(ccumulator), r%1 not set
2093         mov     dpl,r%2
2094         mov     dph,a
2095 %3:
2096         ret
2097 }
2098
2099 // 14 rules by Fiorenzo D. Ramaglia <fd.ramaglia@tin.it>
2100
2101 replace {
2102         add     a,ar%1
2103 } by {
2104         ;       Peephole 236.a  used r%1 instead of ar%1
2105         add     a,r%1
2106 }
2107
2108 replace {
2109         addc    a,ar%1
2110 } by {
2111         ;       Peephole 236.b  used r%1 instead of ar%1
2112         addc    a,r%1
2113 }
2114
2115 replace {
2116         anl     a,ar%1
2117 } by {
2118         ;       Peephole 236.c  used r%1 instead of ar%1
2119         anl     a,r%1
2120 }
2121
2122 replace {
2123         dec     ar%1
2124 } by {
2125         ;       Peephole 236.d  used r%1 instead of ar%1
2126         dec     r%1
2127 }
2128
2129 replace {
2130         djnz    ar%1,%2
2131 } by {
2132         ;       Peephole 236.e  used r%1 instead of ar%1
2133         djnz    r%1,%2
2134 }
2135
2136 replace {
2137         inc     ar%1
2138 } by {
2139         ;       Peephole 236.f  used r%1 instead of ar%1
2140         inc     r%1
2141 }
2142
2143 replace {
2144         mov     a,ar%1
2145 } by {
2146         ;       Peephole 236.g  used r%1 instead of ar%1
2147         mov     a,r%1
2148 }
2149
2150 replace {
2151         mov     ar%1,#%2
2152 } by {
2153         ;       Peephole 236.h  used r%1 instead of ar%1
2154         mov     r%1,#%2
2155 }
2156
2157 replace {
2158         mov     ar%1,a
2159 } by {
2160         ;       Peephole 236.i  used r%1 instead of ar%1
2161         mov     r%1,a
2162 }
2163
2164 replace {
2165         mov     ar%1,ar%2
2166 } by {
2167         ;       Peephole 236.j  used r%1 instead of ar%1
2168         mov     r%1,ar%2
2169 }
2170
2171 replace {
2172         orl     a,ar%1
2173 } by {
2174         ;       Peephole 236.k  used r%1 instead of ar%1
2175         orl     a,r%1
2176 }
2177
2178 replace {
2179         subb    a,ar%1
2180 } by {
2181         ;       Peephole 236.l  used r%1 instead of ar%1
2182         subb    a,r%1
2183 }
2184
2185 replace {
2186         xch     a,ar%1
2187 } by {
2188         ;       Peephole 236.m  used r%1 instead of ar%1
2189         xch     a,r%1
2190 }
2191
2192 replace {
2193         xrl     a,ar%1
2194 } by {
2195         ;       Peephole 236.n  used r%1 instead of ar%1
2196         xrl     a,r%1
2197 }
2198
2199 replace {
2200         sjmp    %1
2201 %2:
2202         mov     %3,%4
2203 %1:
2204         ret
2205 } by {
2206         ;       Peephole 237.a  removed sjmp to ret
2207         ret
2208 %2:
2209         mov     %3,%4
2210 %1:
2211         ret
2212 }
2213
2214 replace {
2215         sjmp    %1
2216 %2:
2217         mov     %3,%4
2218         mov     dpl,%5
2219         mov     dph,%6
2220 %1:
2221         ret
2222 } by {
2223         ;       Peephole 237.b  removed sjmp to ret
2224         ret
2225 %2:
2226         mov     %3,%4
2227         mov     dpl,%5
2228         mov     dph,%6
2229 %1:
2230         ret
2231 }
2232
2233 // applies to f.e. device/lib/log10f.c
2234 replace {
2235         mov     %1,%9
2236         mov     %2,%10
2237         mov     %3,%11
2238         mov     %4,%12
2239
2240         mov     %5,%13
2241         mov     %6,%14
2242         mov     %7,%15
2243         mov     %8,%16
2244
2245         mov     %9,%1
2246         mov     %10,%2
2247         mov     %11,%3
2248         mov     %12,%4
2249 } by {
2250         mov     %1,%9
2251         mov     %2,%10
2252         mov     %3,%11
2253         mov     %4,%12
2254
2255         mov     %5,%13
2256         mov     %6,%14
2257         mov     %7,%15
2258         mov     %8,%16
2259         ;       Peephole 238.a  removed 4 redundant moves
2260 } if operandsNotSame8 %1 %2 %3 %4 %5 %6 %7 %8
2261
2262 // applies to device/lib/log10f.c
2263 replace {
2264         mov     %1,%5
2265         mov     %2,%6
2266         mov     %3,%7
2267         mov     %4,%8
2268
2269         mov     %5,%1
2270         mov     %6,%2
2271         mov     %7,%3
2272 } by {
2273         mov     %1,%5
2274         mov     %2,%6
2275         mov     %3,%7
2276         mov     %4,%8
2277         ;       Peephole 238.b  removed 3 redundant moves
2278 } if operandsNotSame7 %1 %2 %3 %4 %5 %6 %7
2279
2280 // applies to f.e. device/lib/time.c
2281 replace {
2282         mov     %1,%5
2283         mov     %2,%6
2284
2285         mov     %3,%7
2286         mov     %4,%8
2287
2288         mov     %5,%1
2289         mov     %6,%2
2290 } by {
2291         mov     %1,%5
2292         mov     %2,%6
2293
2294         mov     %3,%7
2295         mov     %4,%8
2296         ;       Peephole 238.c  removed 2 redundant moves
2297 } if operandsNotSame4 %1 %2 %3 %4
2298
2299 // applies to f.e. support/regression/tests/bug-524209.c
2300 replace {
2301         mov     %1,%4
2302         mov     %2,%5
2303         mov     %3,%6
2304
2305         mov     %4,%1
2306         mov     %5,%2
2307         mov     %6,%3
2308 } by {
2309         mov     %1,%4
2310         mov     %2,%5
2311         mov     %3,%6
2312         ;       Peephole 238.d  removed 3 redundant moves
2313 } if operandsNotSame6 %1 %2 %3 %4 %5 %6
2314
2315 // applies to f.e. ser_ir.asm
2316 replace {
2317         mov     r%1,acc
2318 } by {
2319         ;       Peephole 239    used a instead of acc
2320         mov     r%1,a
2321 }
2322
2323 replace restart {
2324         mov     a,%1
2325         addc    a,#0x00
2326 } by {
2327         ;       Peephole 240    use clr instead of addc a,#0
2328         clr     a
2329         addc    a,%1
2330 }
2331
2332 // peepholes 241.a to 241.c and 241.d to 241.f need to be in order
2333 replace {
2334         cjne    r%1,#%2,%3
2335         cjne    r%4,#%5,%3
2336         cjne    r%6,#%7,%3
2337         cjne    r%8,#%9,%3
2338         mov     a,#0x01
2339         sjmp    %10
2340 %3:
2341         clr     a
2342 %10:
2343 } by {
2344         ;       Peephole 241.a  optimized compare
2345         clr     a
2346         cjne    r%1,#%2,%3
2347         cjne    r%4,#%5,%3
2348         cjne    r%6,#%7,%3
2349         cjne    r%8,#%9,%3
2350         inc     a
2351 %3:
2352 %10:
2353 }
2354
2355 // applies to f.e. time.c
2356 replace {
2357         cjne    r%1,#%2,%3
2358         cjne    r%4,#%5,%3
2359         mov     a,#0x01
2360         sjmp    %6
2361 %3:
2362         clr     a
2363 %6:
2364 } by {
2365         ;       Peephole 241.b  optimized compare
2366         clr     a
2367         cjne    r%1,#%2,%3
2368         cjne    r%4,#%5,%3
2369         inc     a
2370 %3:
2371 %6:
2372 }
2373
2374 // applies to f.e. malloc.c
2375 replace {
2376         cjne    r%1,#%2,%3
2377         mov     a,#0x01
2378         sjmp    %4
2379 %3:
2380         clr     a
2381 %4:
2382 } by {
2383         ;       Peephole 241.c  optimized compare
2384         clr     a
2385         cjne    r%1,#%2,%3
2386         inc     a
2387 %3:
2388 %4:
2389 }
2390
2391 // applies to f.e. j = (k!=0x1000);
2392 // with volatile idata long k;
2393 replace {
2394         cjne    @r%1,#%2,%3
2395         inc     r%1
2396         cjne    @r%1,#%4,%3
2397         inc     r%1
2398         cjne    @r%1,#%5,%3
2399         inc     r%1
2400         cjne    @r%1,#%6,%3
2401         mov     a,#0x01
2402         sjmp    %7
2403 %3:
2404         clr     a
2405 %7:
2406 } by {
2407         ;       Peephole 241.d  optimized compare
2408         clr     a
2409         cjne    @r%1,#%2,%3
2410         inc     r%1
2411         cjne    @r%1,#%4,%3
2412         inc     r%1
2413         cjne    @r%1,#%5,%3
2414         inc     r%1
2415         cjne    @r%1,#%6,%3
2416         inc     a
2417 %3:
2418 %7:
2419 }
2420
2421 // applies to f.e. j = (k!=0x1000);
2422 // with volatile idata int k;
2423 replace {
2424         cjne    @r%1,#%2,%3
2425         inc     r%1
2426         cjne    @r%1,#%4,%3
2427         mov     a,#0x01
2428         sjmp    %7
2429 %3:
2430         clr     a
2431 %7:
2432 } by {
2433         ;       Peephole 241.e  optimized compare
2434         clr     a
2435         cjne    @r%1,#%2,%3
2436         inc     r%1
2437         cjne    @r%1,#%4,%3
2438         inc     a
2439 %3:
2440 %7:
2441 }
2442
2443 // applies to f.e. vprintf.asm (--stack-auto)
2444 replace {
2445         cjne    @r%1,#%2,%3
2446         mov     a,#0x01
2447         sjmp    %7
2448 %3:
2449         clr     a
2450 %7:
2451 } by {
2452         ;       Peephole 241.f  optimized compare
2453         clr     a
2454         cjne    @r%1,#%2,%3
2455         inc     a
2456 %3:
2457 %7:
2458 }
2459
2460 // applies to f.e. scott-bool1.c
2461 replace {
2462         jnz     %1
2463         mov     %2,%3
2464 %1:
2465         jz      %4
2466 } by {
2467         ;       Peephole 242.a  avoided branch jnz to jz
2468         jnz     %1
2469         mov     %2,%3
2470         jz      %4
2471 %1:
2472 } if labelRefCount %1 1
2473
2474 // applies to f.e. scott-bool1.c
2475 replace {
2476         jnz     %1
2477         mov     %2,%3
2478         orl     a,%5
2479 %1:
2480         jz      %4
2481 } by {
2482         ;       Peephole 242.b  avoided branch jnz to jz
2483         jnz     %1
2484         mov     %2,%3
2485         orl     a,%5
2486         jz      %4
2487 %1:
2488 } if labelRefCount %1 1
2489
2490 // applies to f.e. logic.c
2491 replace {
2492         jnz     %1
2493         mov     %2,%3
2494         orl     a,%5
2495         orl     a,%6
2496         orl     a,%7
2497 %1:
2498         jz      %4
2499 } by {
2500         ;       Peephole 242.c  avoided branch jnz to jz
2501         jnz     %1
2502         mov     %2,%3
2503         orl     a,%5
2504         orl     a,%6
2505         orl     a,%7
2506         jz      %4
2507 %1:
2508 } if labelRefCount %1 1
2509
2510 // applies to f.e. vprintf.c
2511 // this is a rare case, usually the "tail increment" is noticed earlier
2512 replace {
2513         cjne    %1,%2,%3
2514         inc     %4
2515 %3:
2516         sjmp    %5
2517 } by {
2518         ;       Peephole 243    avoided branch to sjmp
2519         cjne    %1,%2,%5
2520         inc     %4
2521 %3:
2522         sjmp    %5
2523 } if labelInRange
2524
2525 // applies to f.e. simplefloat.c (saving 1 cycle)
2526 replace {
2527         mov     r%1,dpl
2528         mov     a,r%1
2529 } by {
2530         ;       Peephole 244.a  moving first to a instead of r%1
2531         mov     a,dpl
2532         mov     r%1,a
2533 }
2534
2535 // applies to f.e. _itoa.c (saving 1 cycle)
2536 replace {
2537         mov     r%1,dph
2538         mov     a,r%1
2539 } by {
2540         ;       Peephole 244.b  moving first to a instead of r%1
2541         mov     a,dph
2542         mov     r%1,a
2543 }
2544
2545
2546 // applies to f.e. bug-460010.c (saving 1 cycle)
2547 replace {
2548         mov     r%1,a
2549         mov     dpl,r%1
2550 } by {
2551         ;       Peephole 244.c  loading dpl from a instead of r%1
2552         mov     r%1,a
2553         mov     dpl,a
2554 }
2555
2556 replace {
2557         mov     r%1,a
2558         mov     dph,r%1
2559 } by {
2560         ;       Peephole 244.d  loading dph from a instead of r%1
2561         mov     r%1,a
2562         mov     dph,a
2563 }
2564
2565 // this one is safe but disables 245.a 245.b
2566 // please remove 245 if 245.a 245.b are found to be safe
2567 // applies to f.e. scott-compare.c
2568 replace {
2569         clr     a
2570         rlc     a
2571         mov     r%1,a
2572         cjne    a,#0x01,%2
2573 %2:
2574         clr     a
2575         rlc     a
2576         mov     r%1,a
2577 } by {
2578         ;       Peephole 245    optimized complement (r%1 and acc set needed?)
2579         cpl     c
2580         clr     a
2581         rlc     a
2582         mov     r%1,a
2583 } if labelRefCount %2 1
2584
2585 // this one will not be triggered if 245 is present
2586 // please remove 245 if 245.a 245.b are found to be safe
2587 // applies to f.e. vprintf.c
2588 replace {
2589         clr     a
2590         rlc     a
2591         mov     r%1,a
2592         cjne    a,#0x01,%2
2593 %2:
2594         clr     a
2595         rlc     a
2596         mov     r%1,a
2597         jz      %3
2598 } by {
2599         ;       Peephole 245.a  optimized conditional jump (r%1 and acc not set!)
2600         jc      %3
2601 } if labelRefCount %2 1
2602
2603 // this one will not be triggered if 245 is present
2604 // please remove 245 if 245.a 245.b are found to be safe
2605 // applies to f.e. scott-compare.c
2606 replace {
2607         clr     a
2608         rlc     a
2609         mov     r%1,a
2610         cjne    a,#0x01,%2
2611 %2:
2612         clr     a
2613         rlc     a
2614         mov     r%1,a
2615         jnz     %3
2616 } by {
2617         ;       Peephole 245.b  optimized conditional jump (r%1 and acc not set!)
2618         jnc     %3
2619 } if labelRefCount %2 1
2620
2621
2622 // rules 246.x apply to f.e. bitfields.c
2623 replace {
2624         mov     dptr,#%1
2625         movx    a,@dptr
2626         anl     a,#%2
2627         movx    @dptr,a
2628         mov     dptr,#%1
2629         movx    a,@dptr
2630         anl     a,#%3
2631         movx    @dptr,a
2632 } by {
2633         ;       Peephole 246.a  combined clr/clr
2634         mov     dptr,#%1
2635         movx    a,@dptr
2636         anl     a,#%2&%3
2637         movx    @dptr,a
2638 } if notVolatile %1
2639
2640 replace {
2641         mov     dptr,#%1
2642         movx    a,@dptr
2643         orl     a,#%2
2644         movx    @dptr,a
2645         mov     dptr,#%1
2646         movx    a,@dptr
2647         orl     a,#%3
2648         movx    @dptr,a
2649 } by {
2650         ;       Peephole 246.b  combined set/set
2651         mov     dptr,#%1
2652         movx    a,@dptr
2653         orl     a,#%2|%3
2654         movx    @dptr,a
2655 } if notVolatile %1
2656
2657 replace {
2658         mov     dptr,#%1
2659         movx    a,@dptr
2660         orl     a,#%2
2661         movx    @dptr,a
2662         mov     dptr,#%1
2663         movx    a,@dptr
2664         anl     a,#%3
2665         movx    @dptr,a
2666 } by {
2667         ;       Peephole 246.c  combined set/clr
2668         mov     dptr,#%1
2669         movx    a,@dptr
2670         orl     a,#%2
2671         anl     a,#%3
2672         movx    @dptr,a
2673 } if notVolatile %1
2674
2675 replace {
2676         mov     dptr,#%1
2677         movx    a,@dptr
2678         anl     a,#%2
2679         movx    @dptr,a
2680         mov     dptr,#%1
2681         movx    a,@dptr
2682         orl     a,#%3
2683         movx    @dptr,a
2684 } by {
2685         ;       Peephole 246.d  combined clr/set
2686         mov     dptr,#%1
2687         movx    a,@dptr
2688         anl     a,#%2
2689         orl     a,#%3
2690         movx    @dptr,a
2691 } if notVolatile %1
2692
2693 replace {
2694         mov     dptr,#%1
2695         movx    a,@dptr
2696         orl     a,#%2
2697         anl     a,#%3
2698         movx    @dptr,a
2699         mov     dptr,#%1
2700         movx    a,@dptr
2701         anl     a,#%4
2702         movx    @dptr,a
2703 } by {
2704         ;       Peephole 246.e  combined set/clr/clr
2705         mov     dptr,#%1
2706         movx    a,@dptr
2707         orl     a,#%2
2708         anl     a,#%3&%4
2709         movx    @dptr,a
2710 } if notVolatile %1
2711
2712 replace {
2713         mov     dptr,#%1
2714         movx    a,@dptr
2715         orl     a,#%2
2716         anl     a,#%3
2717         movx    @dptr,a
2718         mov     dptr,#%1
2719         movx    a,@dptr
2720         orl     a,#%4
2721         movx    @dptr,a
2722 } by {
2723         ;       Peephole 246.f  combined set/clr/set
2724         mov     dptr,#%1
2725         movx    a,@dptr
2726         orl     a,#%2
2727         anl     a,#%3
2728         orl     a,#%4
2729         movx    @dptr,a
2730 } if notVolatile %1
2731
2732 replace {
2733         mov     dptr,#%1
2734         movx    a,@dptr
2735         anl     a,#%2
2736         orl     a,#%3
2737         movx    @dptr,a
2738         mov     dptr,#%1
2739         movx    a,@dptr
2740         anl     a,#%4
2741         movx    @dptr,a
2742 } by {
2743         ;       Peephole 246.g  combined clr/set/clr
2744         mov     dptr,#%1
2745         movx    a,@dptr
2746         anl     a,#%2
2747         orl     a,#%3
2748         anl     a,#%4
2749         movx    @dptr,a
2750 } if notVolatile %1
2751
2752 replace {
2753         mov     dptr,#%1
2754         movx    a,@dptr
2755         anl     a,#%2
2756         orl     a,#%3
2757         movx    @dptr,a
2758         mov     dptr,#%1
2759         movx    a,@dptr
2760         orl     a,#%4
2761         movx    @dptr,a
2762 } by {
2763         ;       Peephole 246.h  combined clr/set/set
2764         mov     dptr,#%1
2765         movx    a,@dptr
2766         anl     a,#%2
2767         orl     a,#%3|%4
2768         movx    @dptr,a
2769 } if notVolatile %1
2770
2771
2772
2773
2774 // rules 247.x apply to f.e. bitfields.c
2775 replace {
2776         mov     r%5,#%1
2777         mov     a,@r%5
2778         anl     a,#%2
2779         mov     @r%5,a
2780         mov     r%5,#%1
2781         mov     a,@r%5
2782         anl     a,#%3
2783         mov     @r%5,a
2784 } by {
2785         ;       Peephole 247.a  combined clr/clr
2786         mov     r%5,#%1
2787         mov     a,@r%5
2788         anl     a,#%2&%3
2789         mov     @r%5,a
2790 } if notVolatile %1
2791
2792 replace {
2793         mov     r%5,#%1
2794         mov     a,@r%5
2795         orl     a,#%2
2796         mov     @r%5,a
2797         mov     r%5,#%1
2798         mov     a,@r%5
2799         orl     a,#%3
2800         mov     @r%5,a
2801 } by {
2802         ;       Peephole 247.b  combined set/set
2803         mov     r%5,#%1
2804         mov     a,@r%5
2805         orl     a,#%2|%3
2806         mov     @r%5,a
2807 } if notVolatile %1
2808
2809 replace {
2810         mov     r%5,#%1
2811         mov     a,@r%5
2812         orl     a,#%2
2813         mov     @r%5,a
2814         mov     r%5,#%1
2815         mov     a,@r%5
2816         anl     a,#%3
2817         mov     @r%5,a
2818 } by {
2819         ;       Peephole 247.c  combined set/clr
2820         mov     r%5,#%1
2821         mov     a,@r%5
2822         orl     a,#%2
2823         anl     a,#%3
2824         mov     @r%5,a
2825 } if notVolatile %1
2826
2827 replace {
2828         mov     r%5,#%1
2829         mov     a,@r%5
2830         anl     a,#%2
2831         mov     @r%5,a
2832         mov     r%5,#%1
2833         mov     a,@r%5
2834         orl     a,#%3
2835         mov     @r%5,a
2836 } by {
2837         ;       Peephole 247.d  combined clr/set
2838         mov     r%5,#%1
2839         mov     a,@r%5
2840         anl     a,#%2
2841         orl     a,#%3
2842         mov     @r%5,a
2843 } if notVolatile %1
2844
2845 replace {
2846         mov     r%5,#%1
2847         mov     a,@r%5
2848         orl     a,#%2
2849         anl     a,#%3
2850         mov     @r%5,a
2851         mov     r%5,#%1
2852         mov     a,@r%5
2853         anl     a,#%4
2854         mov     @r%5,a
2855 } by {
2856         ;       Peephole 247.e  combined set/clr/clr
2857         mov     r%5,#%1
2858         mov     a,@r%5
2859         orl     a,#%2
2860         anl     a,#%3&%4
2861         mov     @r%5,a
2862 } if notVolatile %1
2863
2864 replace {
2865         mov     r%5,#%1
2866         mov     a,@r%5
2867         orl     a,#%2
2868         anl     a,#%3
2869         mov     @r%5,a
2870         mov     r%5,#%1
2871         mov     a,@r%5
2872         orl     a,#%4
2873         mov     @r%5,a
2874 } by {
2875         ;       Peephole 247.f  combined set/clr/set
2876         mov     r%5,#%1
2877         mov     a,@r%5
2878         orl     a,#%2
2879         anl     a,#%3
2880         orl     a,#%4
2881         mov     @r%5,a
2882 } if notVolatile %1
2883
2884 replace {
2885         mov     r%5,#%1
2886         mov     a,@r%5
2887         anl     a,#%2
2888         orl     a,#%3
2889         mov     @r%5,a
2890         mov     r%5,#%1
2891         mov     a,@r%5
2892         anl     a,#%4
2893         mov     @r%5,a
2894 } by {
2895         ;       Peephole 247.g  combined clr/set/clr
2896         mov     r%5,#%1
2897         mov     a,@r%5
2898         anl     a,#%2
2899         orl     a,#%3
2900         anl     a,#%4
2901         mov     @r%5,a
2902 } if notVolatile %1
2903
2904 replace {
2905         mov     r%5,#%1
2906         mov     a,@r%5
2907         anl     a,#%2
2908         orl     a,#%3
2909         mov     @r%5,a
2910         mov     r%5,#%1
2911         mov     a,@r%4
2912         orl     a,#%4
2913         mov     @r%5,a
2914 } by {
2915         ;       Peephole 247.h  combined clr/set/set
2916         mov     r%5,#%1
2917         mov     a,@r%5
2918         anl     a,#%2
2919         orl     a,#%3|%4
2920         mov     @r%5,a
2921 } if notVolatile %1
2922
2923
2924 // Peepholes 248.x have to be compatible with the keyword volatile.
2925 // They optimize typical accesses to memory mapped I/O devices:
2926 // volatile xdata char t; t|=0x01;
2927 replace {
2928         mov     dptr,%1
2929         movx    a,@dptr
2930         mov     r%2,a
2931         mov     dptr,%1
2932         mov     a,%3
2933         orl     a,r%2
2934         movx    @dptr,a
2935 } by {
2936         ;       Peephole 248.a  optimized or to xdata
2937         mov     dptr,%1
2938         movx    a,@dptr
2939         mov     r%2,a
2940         orl     a,%3
2941         movx    @dptr,a
2942 }
2943
2944 // volatile xdata char t; t&=0x01;
2945 replace {
2946         mov     dptr,%1
2947         movx    a,@dptr
2948         mov     r%2,a
2949         mov     dptr,%1
2950         mov     a,%3
2951         anl     a,r%2
2952         movx    @dptr,a
2953 } by {
2954         ;       Peephole 248.b  optimized and to xdata
2955         mov     dptr,%1
2956         movx    a,@dptr
2957         mov     r%2,a
2958         anl     a,%3
2959         movx    @dptr,a
2960 }
2961
2962 // volatile xdata char t; t^=0x01;
2963 replace {
2964         mov     dptr,%1
2965         movx    a,@dptr
2966         mov     r%2,a
2967         mov     dptr,%1
2968         mov     a,%3
2969         xrl     a,r%2
2970         movx    @dptr,a
2971 } by {
2972         ;       Peephole 248.c  optimized xor to xdata
2973         mov     dptr,%1
2974         movx    a,@dptr
2975         mov     r%2,a
2976         xrl     a,%3
2977         movx    @dptr,a
2978 }
2979
2980 // volatile xdata char t; t|=0x01; t&=~0x01; t|=0x01;
2981 replace {
2982         mov     dptr,%1
2983         movx    a,@dptr
2984         mov     r%2,a
2985         orl     a,%3
2986         movx    @dptr,a
2987
2988         mov     dptr,%1
2989         movx    a,@dptr
2990         mov     r%2,a
2991         anl     a,%4
2992         movx    @dptr,a
2993
2994         mov     dptr,%1
2995         movx    a,@dptr
2996         mov     r%2,a
2997         orl     a,%5
2998         movx    @dptr,a
2999 } by {
3000         ;       Peephole 248.d  optimized or/and/or to volatile xdata
3001         mov     dptr,%1
3002         movx    a,@dptr
3003         orl     a,%3
3004         movx    @dptr,a
3005         movx    a,@dptr
3006         anl     a,%4
3007         movx    @dptr,a
3008         movx    a,@dptr
3009         mov     r%2,a
3010         orl     a,%5
3011         movx    @dptr,a
3012 }
3013
3014 // volatile xdata char t; t&=~0x01; t|=0x01; t&=~0x01;
3015 replace {
3016         mov     dptr,%1
3017         movx    a,@dptr
3018         mov     r%2,a
3019         anl     a,%3
3020         movx    @dptr,a
3021
3022         mov     dptr,%1
3023         movx    a,@dptr
3024         mov     r%2,a
3025         orl     a,%4
3026         movx    @dptr,a
3027
3028         mov     dptr,%1
3029         movx    a,@dptr
3030         mov     r%2,a
3031         anl     a,%5
3032         movx    @dptr,a
3033 } by {
3034         ;       Peephole 248.e  optimized and/or/and to volatile xdata
3035         mov     dptr,%1
3036         movx    a,@dptr
3037         anl     a,%3
3038         movx    @dptr,a
3039         movx    a,@dptr
3040         orl     a,%4
3041         movx    @dptr,a
3042         movx    a,@dptr
3043         mov     r%2,a
3044         anl     a,%5
3045         movx    @dptr,a
3046 }
3047
3048 // volatile xdata char t; t|=0x01; t&=~0x01;
3049 replace {
3050         mov     dptr,%1
3051         movx    a,@dptr
3052         mov     r%2,a
3053         orl     a,%3
3054         movx    @dptr,a
3055
3056         mov     dptr,%1
3057         movx    a,@dptr
3058         mov     r%2,a
3059         anl     a,%4
3060         movx    @dptr,a
3061 } by {
3062         ;       Peephole 248.f  optimized or/and to volatile xdata
3063         mov     dptr,%1
3064         movx    a,@dptr
3065         orl     a,%3
3066         movx    @dptr,a
3067         movx    a,@dptr
3068         mov     r%2,a
3069         anl     a,%4
3070         movx    @dptr,a
3071 }
3072
3073 // volatile xdata char t; t&=~0x01; t|=0x01;
3074 replace {
3075         mov     dptr,%1
3076         movx    a,@dptr
3077         mov     r%2,a
3078         anl     a,%3
3079         movx    @dptr,a
3080
3081         mov     dptr,%1
3082         movx    a,@dptr
3083         mov     r%2,a
3084         orl     a,%4
3085         movx    @dptr,a
3086 } by {
3087         ;       Peephole 248.g  optimized and/or to volatile xdata
3088         mov     dptr,%1
3089         movx    a,@dptr
3090         anl     a,%3
3091         movx    @dptr,a
3092         movx    a,@dptr
3093         mov     r%2,a
3094         orl     a,%4
3095         movx    @dptr,a
3096 }
3097
3098 // volatile xdata char t; t^=0x01; t^=0x01;
3099 replace {
3100         mov     dptr,%1
3101         movx    a,@dptr
3102         mov     r%2,a
3103         xrl     a,%3
3104         movx    @dptr,a
3105
3106         mov     dptr,%1
3107         movx    a,@dptr
3108         mov     r%2,a
3109         xrl     a,%4
3110         movx    @dptr,a
3111 } by {
3112         ;       Peephole 248.h  optimized xor/xor to volatile xdata
3113         mov     dptr,%1
3114         movx    a,@dptr
3115         xrl     a,%3
3116         movx    @dptr,a
3117         movx    a,@dptr
3118         mov     r%2,a
3119         xrl     a,%4
3120         movx    @dptr,a
3121 }
3122
3123 replace {
3124         jnz     %1
3125 %1:
3126 } by {
3127         ;       Peephole 249.a   jump optimization
3128 } if labelRefCount %1 1
3129
3130 replace {
3131         jz      %1
3132 %1:
3133 } by {
3134         ;       Peephole 249.b   jump optimization
3135 } if labelRefCount %1 1
3136
3137
3138 // This allows non-interrupt and interrupt code to safely compete
3139 // for a resource without the non-interrupt code having to disable
3140 // interrupts:
3141 // volatile bit resource_is_free;
3142 // if( resource_is_free ) {
3143 //     resource_is_free=0; do_something; resource_is_free=1;
3144 // }
3145 replace {
3146         jnb     %1,%2
3147 %3:
3148         clr     %1
3149 } by {
3150         ;       Peephole 250.a  using atomic test and clear
3151         jbc     %1,%3
3152         sjmp    %2
3153 %3:
3154 } if labelRefCount %3 0
3155
3156 replace {
3157         jb      %1,%2
3158         ljmp    %3
3159 %2:
3160         clr     %1
3161 } by {
3162         ;       Peephole 250.b  using atomic test and clear
3163         jbc     %1,%2
3164         ljmp    %3
3165 %2:
3166 } if labelRefCount %2 1
3167
3168
3169 // not before peephole 250.b
3170 replace {
3171         ljmp    %5
3172 } by {
3173         ;       Peephole 251.a  replaced ljmp to ret with ret
3174         ret
3175 } if labelIsReturnOnly
3176
3177 // not before peephole 250.b
3178 replace {
3179         sjmp    %5
3180 } by {
3181         ;       Peephole 251.b  replaced sjmp to ret with ret
3182         ret
3183 } if labelIsReturnOnly
3184
3185 // applies to shifts.c and when accessing arrays with an unsigned integer index
3186 // saving 1 byte, 2 cycles
3187 replace {
3188         mov     r%1,%2
3189         mov     a,(%2 + 1)
3190         xch     a,r%1
3191         add     a,acc
3192         xch     a,r%1
3193         rlc     a
3194         mov     r%3,a
3195 } by {
3196         ;       Peephole 252    optimized left shift
3197         mov     a,%2
3198         add     a,acc
3199         mov     r%1,a
3200         mov     a,(%2 + 1)
3201         rlc     a
3202         mov     r%3,a
3203 }
3204
3205 // applies to: void test( char c ) { if( c ) func1(); else func2(); }
3206 replace {
3207         lcall   %1
3208         ret
3209 } by {
3210         ;       Peephole 253.a  replaced lcall/ret with ljmp
3211         ljmp    %1
3212 }
3213
3214 // applies to: void test( char c ) { if( c ) func1(); else func2(); }
3215 replace {
3216         lcall   %1
3217 %2:
3218         ret
3219 } by {
3220         ;       Peephole 253.b  replaced lcall/ret with ljmp
3221         ljmp    %1
3222 } if labelRefCount %2 0
3223
3224 // applies to f.e. scott-bool1.c
3225 replace {
3226         lcall   %1
3227 %2:
3228         ret
3229 } by {
3230         ;       Peephole 253.c  replaced lcall with ljmp
3231         ljmp    %1
3232 %2:
3233         ret
3234 }
3235
3236
3237 // applies to f.e. funptrs.c
3238 // saves one byte if %1 is a register or @register
3239 replace {
3240         mov     a,%1
3241         add     a,acc
3242 } by {
3243         ;       Peephole 254    optimized left shift
3244         mov     a,%1
3245         add     a,%1
3246 } if notVolatile %1
3247
3248 // applies to f.e. switch.c
3249 replace {
3250         clr     c
3251         mov     a,#%1
3252         subb    a,%2
3253         jc      %3
3254 %4:
3255         mov     a,%2
3256         add     a,%2
3257         add     a,%2
3258         mov     dptr,%5
3259         jmp     @a+dptr
3260 } by {
3261         ;       Peephole 255    optimized jump table index calculation
3262         mov     a,%2
3263         cjne    a,#(%1+0x01),.+1
3264         jnc     %3
3265 %4:
3266         add     a,%2
3267         add     a,%2
3268         mov     dptr,%5
3269         jmp     @a+dptr
3270 }
3271
3272 // applies to f.e. jump tables and scott-bool1.c.
3273 // similar peepholes can be constructed for other instructions
3274 // after which a flag or a register is known (like: djnz, cjne, jnc)
3275 replace {
3276         jc      %1
3277 %2:
3278         clr     c
3279 } by {
3280         ;       Peephole 256.a  removed redundant clr c
3281         jc      %1
3282 %2:
3283 } if labelRefCount %2 0
3284
3285 // applies to f.e. logf.c
3286 replace {
3287         jnz     %1
3288 %2:
3289         clr     a
3290 } by {
3291         ;       Peephole 256.b  removed redundant clr a
3292         jnz     %1
3293 %2:
3294 } if labelRefCount %2 0
3295
3296
3297 // unsigned char i=8; do{ } while(--i != 0);
3298 // this currently only applies if i is kept in a register
3299 replace {
3300         dec     %1
3301         cjne    %1,#0x00,%2
3302 } by {
3303         ;       Peephole 257    optimized decrement with compare
3304         djnz    %1,%2
3305 } if notVolatile %1
3306
3307
3308 // in_byte<<=1; if(in_bit) in_byte|=1;
3309 // helps f.e. reading data on a 3-wire (SPI) bus
3310 replace {
3311         mov     a,%1
3312         add     a,%1
3313         mov     %1,a
3314         jnb     %2,%3
3315 %4:
3316         orl     %1,#0x01
3317 %3:
3318 } by {
3319         ;       Peephole 258.a  optimized bitbanging
3320         mov     a,%1
3321         mov     c,%2
3322         addc    a,%1
3323         mov     %1,a
3324 %4:
3325 %3:
3326 } if notVolatile %1
3327
3328 // in_byte<<=1; if(in_bit) in_byte|=1;
3329 replace {
3330         mov     a,r%1
3331         add     a,r%1
3332         mov     r%1,a
3333         jnb     %2,%3
3334 %4:
3335         orl     ar%1,#0x01
3336 %3:
3337 } by {
3338         ;       Peephole 258.b  optimized bitbanging
3339         mov     a,r%1
3340         mov     c,%2
3341         addc    a,r%1
3342         mov     r%1,a
3343 %4:
3344 %3:
3345 }
3346
3347 // in_byte>>=1; if(in_bit) in_byte|=0x80;
3348 replace {
3349         mov     a,%1
3350         clr     c
3351         rrc     a
3352         mov     %1,a
3353         jnb     %2,%3
3354 %4:
3355         orl     %1,#0x80
3356 %3:
3357 } by {
3358         ;       Peephole 258.c  optimized bitbanging
3359         mov     a,%1
3360         mov     c,%2
3361         rrc     a
3362         mov     %1,a
3363 %4:
3364 %3:
3365 } if notVolatile %1
3366
3367 // in_byte>>=1; if(in_bit) in_byte|=0x80;
3368 replace {
3369         mov     a,r%1
3370         clr     c
3371         rrc     a
3372         mov     r%1,a
3373         jnb     %2,%3
3374 %4:
3375         orl     ar%1,#0x80
3376 %3:
3377 } by {
3378         ;       Peephole 258.d  optimized bitbanging
3379         mov     a,r%1
3380         mov     c,%2
3381         rrc     a
3382         mov     r%1,a
3383 %4:
3384 %3:
3385 }
3386
3387 // out_bit=out_byte&0x80; out_byte<<=1;
3388 // helps f.e. writing data on a 3-wire (SPI) bus
3389 replace {
3390         mov     a,%1
3391         mov     c,acc.7
3392         mov     %2,c
3393         mov     a,%1
3394         add     a,%1
3395         mov     %1,a
3396 } by {
3397         ;       Peephole 258.e  optimized bitbanging
3398         mov     a,%1
3399         add     a,%1
3400         mov     %2,c
3401         mov     %1,a
3402 } if notVolatile %1
3403
3404 // out_bit=out_byte&0x01; out_byte>>=1;
3405 replace {
3406         mov     a,%1
3407         mov     c,acc.0
3408         mov     %2,c
3409         mov     a,%1
3410         clr     c
3411         rrc     a
3412         mov     %1,a
3413 } by {
3414         ;       Peephole 258.f  optimized bitbanging
3415         mov     a,%1
3416         clr     c
3417         rrc     a
3418         mov     %2,c
3419         mov     %1,a
3420 } if notVolatile %1
3421