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 replace {
1036         mov     a,%1
1037         mov     b,a
1038         mov     a,%2
1039 } by {
1040         ;       Peephole 178    removed redundant mov
1041         mov     b,%1
1042         mov     a,%2
1043 }
1044
1045 // rules 179-182 provided by : Frieder <fe@lake.iup.uni-heidelberg.de>
1046 // saving 2 byte, 1 cycle
1047 replace {
1048         mov     b,#0x00
1049         mov     a,#0x00
1050 } by {
1051         ;       Peephole 179    changed mov to clr
1052         clr     a
1053         mov     b,a
1054 }
1055
1056 // applies to:
1057 // volatile xdata char t; t=0x01; t=0x03;
1058 replace {
1059         mov     dptr,%1
1060         mov     a,%2
1061         movx    @dptr,a
1062         mov     dptr,%1
1063 } by {
1064         ;       Peephole 180.a  removed redundant mov to dptr
1065         mov     dptr,%1
1066         mov     a,%2
1067         movx    @dptr,a
1068 }
1069
1070 // volatile xdata char t; t=0x01; t=0x03; t=0x01;
1071 replace {
1072         mov     dptr,%1
1073         mov     a,%2
1074         movx    @dptr,a
1075         mov     a,%3
1076         movx    @dptr,a
1077         mov     dptr,%1
1078 } by {
1079         ;       Peephole 180.b  removed redundant mov to dptr
1080         mov     dptr,%1
1081         mov     a,%2
1082         movx    @dptr,a
1083         mov     a,%3
1084         movx    @dptr,a
1085 }
1086
1087 // saving 1 byte, 0 cycles
1088 replace {
1089         mov     a,#0x00
1090 } by {
1091         ;       Peephole 181    changed mov to clr
1092         clr     a
1093 }
1094
1095 // saving 3 bytes, 2 cycles
1096 // provided by Bernhard Held <bernhard.held@de.westinghouse.com>
1097 replace {
1098         mov     dpl,#%1
1099         mov     dph,#(%1 >> 8)
1100 } by {
1101         ;       Peephole 182.a  used 16 bit load of DPTR
1102         mov     dptr,#%1
1103 }
1104
1105 // saving 3 byte, 2 cycles, return(NULL) profits here
1106 replace {
1107         mov     dpl,#0x%1
1108         mov     dph,#0x%2
1109 } by {
1110         ;       Peephole 182.b  used 16 bit load of dptr
1111         mov     dptr,#0x%2%1
1112 }
1113
1114 // saving 3 byte, 2 cycles. Probably obsoleted by 182.b
1115 replace {
1116         mov     dpl,#%1
1117         mov     dph,#%2
1118 } by {
1119         ;       Peephole 182.c  used 16 bit load of dptr
1120         mov     dptr,#(((%2)<<8) + %1)
1121 }
1122
1123 // applies to return 0.0; in f.e. sincosf.c
1124 replace {
1125         mov     dpl,#%1
1126         clr     a
1127         mov     dph,a
1128 } by {
1129         ;       Peephole 182.d  used 16 bit load of dptr
1130         mov     dptr,#(%1&0x00ff)
1131         clr     a
1132 }
1133
1134 replace {
1135         anl     %1,#%2
1136         anl     %1,#%3
1137 } by {
1138         ;       Peephole 183    avoided anl during execution
1139         anl     %1,#(%2 & %3)
1140 }
1141
1142 replace {
1143         mov     %1,a
1144         cpl     a
1145         mov     %1,a
1146 } by {
1147         ;       Peephole 184    removed redundant mov
1148         cpl     a
1149         mov     %1,a
1150 } if notVolatile %1
1151
1152 replace {
1153 // acc being incremented might cause problems
1154         mov     %1,a
1155         inc     %1
1156 } by {
1157         ;       Peephole 185    changed order of increment (acc incremented also!)
1158         inc     a
1159         mov     %1,a
1160 } if notVolatile %1
1161
1162 replace {
1163         add     a,#%1
1164         mov     dpl,a
1165         clr     a
1166         addc    a,#(%1 >> 8)
1167         mov     dph,a
1168         clr     a
1169         movc    a,@a+dptr
1170         mov     %2,a
1171         inc     dptr
1172         clr     a
1173         movc    a,@a+dptr
1174         mov     %3,a
1175         inc     dptr
1176         clr     a
1177         movc    a,@a+dptr
1178         mov     %4,a
1179         inc     dptr
1180         clr     a
1181 } by {
1182         ;       Peephole 186.a  optimized movc sequence
1183         mov     dptr,#%1
1184         mov     b,acc
1185         movc    a,@a+dptr
1186         mov     %2,a
1187         mov     acc,b
1188         inc     dptr
1189         movc    a,@a+dptr
1190         mov     %3,a
1191         mov     acc,b
1192         inc     dptr
1193         movc    a,@a+dptr
1194         mov     %4,a
1195         mov     acc,b
1196         inc     dptr
1197 }
1198
1199 replace {
1200         add     a,#%1
1201         mov     dpl,a
1202         clr     a
1203         addc    a,#(%1 >> 8)
1204         mov     dph,a
1205         clr     a
1206         movc    a,@a+dptr
1207         mov     %2,a
1208         inc     dptr
1209         clr     a
1210         movc    a,@a+dptr
1211         mov     %3,a
1212         inc     dptr
1213         clr     a
1214 } by {
1215         ;       Peephole 186.b  optimized movc sequence
1216         mov     dptr,#%1
1217         mov     b,acc
1218         movc    a,@a+dptr
1219         mov     %2,a
1220         mov     acc,b
1221         inc     dptr
1222         movc    a,@a+dptr
1223         mov     %3,a
1224         mov     acc,b
1225         inc     dptr
1226 }
1227
1228 replace {
1229         add     a,#%1
1230         mov     dpl,a
1231         clr     a
1232         addc    a,#(%1 >> 8)
1233         mov     dph,a
1234         clr     a
1235         movc    a,@a+dptr
1236         mov     %2,a
1237         inc     dptr
1238         clr     a
1239 } by {
1240         ;       Peephole 186.c  optimized movc sequence
1241         mov     dptr,#%1
1242         mov     b,acc
1243         movc    a,@a+dptr
1244         mov     %2,a
1245         mov     acc,b
1246         inc     dptr
1247 }
1248
1249 // char indexed access to: char code table[] = {4,3,2,1};
1250 replace {
1251         add     a,#%1
1252         mov     dpl,a
1253         clr     a
1254         addc    a,#(%1 >> 8)
1255         mov     dph,a
1256         clr     a
1257         movc    a,@a+dptr
1258 } by {
1259         ;       Peephole 186.d  optimized movc sequence
1260         mov     dptr,#%1
1261         movc    a,@a+dptr
1262 }
1263
1264 // char indexed access to: int code table[] = {4,3,2,1};
1265 replace {
1266         mov     b,#0x02
1267         mul     ab
1268         add     a,#%2
1269         mov     dpl,a
1270         mov     a,b
1271         addc    a,#(%2 >> 8)
1272         mov     dph,a
1273         clr     a
1274         movc    a,@a+dptr
1275         mov     %3,a
1276         mov     a,#0x01
1277         movc    a,@a+dptr
1278 } by {
1279         ;       Peephole 186.e  optimized movc sequence (b, dptr differ)
1280         add     a,acc
1281         mov     b,a
1282         mov     dptr,#%2
1283         jnc     .+3
1284         inc     dph
1285         movc    a,@a+dptr
1286         mov     %3,a
1287         mov     a,b
1288         inc     a
1289         movc    a,@a+dptr
1290 }
1291
1292 replace {
1293         mov     r%1,%2
1294         anl     ar%1,#%3
1295         mov     a,r%1
1296 } by {
1297         ;       Peephole 187    used a instead of ar%1 for anl
1298         mov     a,%2
1299         anl     a,#%3
1300         mov     r%1,a
1301 }
1302
1303 replace {
1304         mov     %1,a
1305         mov     dptr,%2
1306         movc    a,@a+dptr
1307         mov     %1,a
1308 } by {
1309         ;       Peephole 188    removed redundant mov
1310         mov     dptr,%2
1311         movc    a,@a+dptr
1312         mov     %1,a
1313 } if notVolatile %1
1314
1315 replace {
1316         anl     a,#0x0f
1317         mov     %1,a
1318         mov     a,#0x0f
1319         anl     a,%1
1320 } by {
1321         ;       Peephole 189    removed redundant mov and anl
1322         anl     a,#0x0f
1323         mov     %1,a
1324 } if notVolatile %1
1325
1326 // rules 190 & 191 need to be in order
1327 replace {
1328         mov     a,%1
1329         lcall   __gptrput
1330         mov     a,%1
1331 } by {
1332         ;       Peephole 190    removed redundant mov
1333         mov     a,%1
1334         lcall   __gptrput
1335 } if notVolatile %1
1336
1337 replace {
1338         mov     %1,a
1339         mov     dpl,%2
1340         mov     dph,%3
1341         mov     b,%4
1342         mov     a,%1
1343 } by {
1344         ;       Peephole 191    removed redundant mov
1345         mov     %1,a
1346         mov     dpl,%2
1347         mov     dph,%3
1348         mov     b,%4
1349 } if notVolatile %1
1350
1351 replace {
1352         mov     r%1,a
1353         mov     @r%2,ar%1
1354 } by {
1355         ;       Peephole 192    used a instead of ar%1 as source
1356         mov     r%1,a
1357         mov     @r%2,a
1358 }
1359
1360 replace {
1361         jnz     %3
1362         mov     a,%4
1363         jnz     %3
1364         mov     a,%9
1365         jnz     %3
1366         mov     a,%12
1367         cjne    %13,%14,%3
1368         sjmp    %7
1369 %3:
1370         sjmp    %8
1371 } by {
1372         ;       Peephole 193.a  optimized misc jump sequence
1373         jnz     %8
1374         mov     a,%4
1375         jnz     %8
1376         mov     a,%9
1377         jnz     %8
1378         mov     a,%12
1379         cjne    %13,%14,%8
1380         sjmp    %7
1381 ;%3:
1382 } if labelRefCount %3 4
1383
1384 replace {
1385         cjne    %1,%2,%3
1386         mov     a,%4
1387         cjne    %5,%6,%3
1388         mov     a,%9
1389         cjne    %10,%11,%3
1390         mov     a,%12
1391         cjne    %13,%14,%3
1392         sjmp    %7
1393 %3:
1394         sjmp    %8
1395 } by {
1396         ;       Peephole 193.b  optimized misc jump sequence
1397         cjne    %1,%2,%8
1398         mov     a,%4
1399         cjne    %5,%6,%8
1400         mov     a,%9
1401         cjne    %10,%11,%8
1402         mov     a,%12
1403         cjne    %13,%14,%8
1404         sjmp    %7
1405 ;%3:
1406 } if labelRefCount %3 4
1407
1408 replace {
1409         cjne    @%1,%2,%3
1410         inc     %1
1411         cjne    @%1,%6,%3
1412         inc     %1
1413         cjne    @%1,%11,%3
1414         inc     %1
1415         cjne    @%1,%14,%3
1416         sjmp    %7
1417 %3:
1418         sjmp    %8
1419 } by {
1420         ;       Peephole 193.c  optimized misc jump sequence
1421         cjne    @%1,%2,%8
1422         inc     %1
1423         cjne    @%1,%6,%8
1424         inc     %1
1425         cjne    @%1,%11,%8
1426         inc     %1
1427         cjne    @%1,%14,%8
1428         sjmp    %7
1429 ;%3:
1430 } if labelRefCount %3 4
1431
1432 replace {
1433         cjne    %1,%2,%3
1434         cjne    %5,%6,%3
1435         cjne    %10,%11,%3
1436         cjne    %13,%14,%3
1437         sjmp    %7
1438 %3:
1439         sjmp    %8
1440 } by {
1441         ;       Peephole 194    optimized misc jump sequence
1442         cjne    %1,%2,%8
1443         cjne    %5,%6,%8
1444         cjne    %10,%11,%8
1445         cjne    %13,%14,%8
1446         sjmp    %7
1447 ;%3:
1448 } if labelRefCount %3 4
1449
1450 replace {
1451         jnz     %3
1452         mov     a,%4
1453         jnz     %3
1454         mov     a,%9
1455         cjne    %10,%11,%3
1456         sjmp    %7
1457 %3:
1458         sjmp    %8
1459 } by {
1460         ;       Peephole 195.a  optimized misc jump sequence
1461         jnz     %8
1462         mov     a,%4
1463         jnz     %8
1464         mov     a,%9
1465         cjne    %10,%11,%8
1466         sjmp    %7
1467 ;%3:
1468 } if labelRefCount %3 3
1469
1470 replace {
1471         cjne    %1,%2,%3
1472         mov     a,%4
1473         cjne    %5,%6,%3
1474         mov     a,%9
1475         cjne    %10,%11,%3
1476         sjmp    %7
1477 %3:
1478         sjmp    %8
1479 } by {
1480         ;       Peephole 195.b  optimized misc jump sequence
1481         cjne    %1,%2,%8
1482         mov     a,%4
1483         cjne    %5,%6,%8
1484         mov     a,%9
1485         cjne    %10,%11,%8
1486         sjmp    %7
1487 ;%3:
1488 } if labelRefCount %3 3
1489
1490 replace {
1491         cjne    @%1,%2,%3
1492         inc     %1
1493         cjne    @%1,%6,%3
1494         inc     %1
1495         cjne    @%1,%11,%3
1496         sjmp    %7
1497 %3:
1498         sjmp    %8
1499 } by {
1500         ;       Peephole 195.c  optimized misc jump sequence
1501         cjne    @%1,%2,%8
1502         inc     %1
1503         cjne    @%1,%6,%8
1504         inc     %1
1505         cjne    @%1,%11,%8
1506         sjmp    %7
1507 ;%3:
1508 } if labelRefCount %3 3
1509
1510 replace {
1511         cjne    %1,%2,%3
1512         cjne    %5,%6,%3
1513         cjne    %10,%11,%3
1514         sjmp    %7
1515 %3:
1516         sjmp    %8
1517 } by {
1518         ;       Peephole 196    optimized misc jump sequence
1519         cjne    %1,%2,%8
1520         cjne    %5,%6,%8
1521         cjne    %10,%11,%8
1522         sjmp    %7
1523 ;%3:
1524 } if labelRefCount %3 3
1525
1526 replace {
1527         jnz     %3
1528         mov     a,%4
1529         cjne    %5,%6,%3
1530         sjmp    %7
1531 %3:
1532         sjmp    %8
1533 } by {
1534         ;       Peephole 197.a  optimized misc jump sequence
1535         jnz     %8
1536         mov     a,%4
1537         cjne    %5,%6,%8
1538         sjmp    %7
1539 ;%3:
1540 } if labelRefCount %3 2
1541
1542 replace {
1543         cjne    %1,%2,%3
1544         mov     a,%4
1545         cjne    %5,%6,%3
1546         sjmp    %7
1547 %3:
1548         sjmp    %8
1549 } by {
1550         ;       Peephole 197.b  optimized misc jump sequence
1551         cjne    %1,%2,%8
1552         mov     a,%4
1553         cjne    %5,%6,%8
1554         sjmp    %7
1555 ;%3:
1556 } if labelRefCount %3 2
1557
1558 replace {
1559         cjne     @%1,%2,%3
1560         inc     %1
1561         cjne    @%1,%6,%3
1562         sjmp    %7
1563 %3:
1564         sjmp    %8
1565 } by {
1566         ;       Peephole 197.c  optimized misc jump sequence
1567         cjne    @%1,%2,%8
1568         inc     %1
1569         cjne    @%1,%6,%8
1570         sjmp    %7
1571 ;%3:
1572 } if labelRefCount %3 2
1573
1574 replace {
1575         cjne    %1,%2,%3
1576         cjne    %5,%6,%3
1577         sjmp    %7
1578 %3:
1579         sjmp    %8
1580 } by {
1581         ;       Peephole 198    optimized misc jump sequence
1582         cjne    %1,%2,%8
1583         cjne    %5,%6,%8
1584         sjmp    %7
1585 ;%3:
1586 } if labelRefCount %3 2
1587
1588 replace {
1589         cjne    %1,%2,%3
1590         sjmp    %4
1591 %3:
1592         sjmp    %5
1593 } by {
1594         ;       Peephole 199    optimized misc jump sequence
1595         cjne    %1,%2,%5
1596         sjmp    %4
1597 ;%3:
1598 } if labelRefCount %3 1
1599
1600 replace {
1601         sjmp    %1
1602 %1:
1603 } by {
1604         ;       Peephole 200    removed redundant sjmp
1605 %1:
1606 }
1607
1608 replace {
1609         sjmp    %1
1610 %2:
1611 %1:
1612 } by {
1613         ;       Peephole 201    removed redundant sjmp
1614 %2:
1615 %1:
1616 }
1617
1618 replace {
1619         push    acc
1620         mov     dptr,%1
1621         pop     acc
1622 } by {
1623         ;       Peephole 202    removed redundant push pop
1624         mov     dptr,%1
1625 }
1626
1627 replace {
1628         mov     r%1,_spx
1629         lcall   %2
1630         mov     r%1,_spx
1631 } by {
1632         ;       Peephole 203    removed mov  r%1,_spx
1633         lcall   %2
1634 }
1635
1636 replace {
1637         mov     %1,a
1638         add     a,acc
1639         mov     %1,a
1640 } by {
1641         ;       Peephole 204    removed redundant mov
1642         add     a,acc
1643         mov     %1,a
1644 } if notVolatile %1
1645
1646 replace {
1647         djnz    %1,%2
1648         sjmp    %3
1649 %2:
1650         sjmp    %4
1651 %3:
1652 } by {
1653         ;       Peephole 205    optimized misc jump sequence
1654         djnz    %1,%4
1655 %2:
1656 %3:
1657 } if labelRefCount %2 1
1658
1659 replace {
1660         mov     %1,%1
1661 } by {
1662         ;       Peephole 206    removed redundant mov %1,%1
1663 } if notVolatile
1664
1665 replace {
1666         mov     a,_bp
1667         add     a,#0x00
1668         mov     %1,a
1669 } by {
1670         ;       Peephole 207    removed zero add (acc not set to %1, flags undefined)
1671         mov     %1,_bp
1672 }
1673
1674 replace {
1675         push    acc
1676         mov     r%1,_bp
1677         pop     acc
1678 } by {
1679         ;       Peephole 208    removed redundant push pop
1680         mov     r%1,_bp
1681 }
1682
1683 replace {
1684         mov     a,_bp
1685         add     a,#0x00
1686         inc     a
1687         mov     %1,a
1688 } by {
1689         ;       Peephole 209    optimized increment (acc not set to %1, flags undefined)
1690         mov     %1,_bp
1691         inc     %1
1692 }
1693
1694 replace {
1695         mov     dptr,#((((%1 >> 8)) <<8) + %1)
1696 } by {
1697         ;       Peephole 210    simplified expression
1698         mov     dptr,#%1
1699 }
1700
1701 replace {
1702         push    %1
1703         pop     %1
1704 } by {
1705         ;       Peephole 211    removed redundant push %1 pop %1
1706 }
1707
1708 replace {
1709         mov     a,_bp
1710         add     a,#0x01
1711         mov     r%1,a
1712 } by {
1713         ;       Peephole 212    reduced add sequence to inc
1714         mov     r%1,_bp
1715         inc     r%1
1716 }
1717
1718 replace {
1719         mov     %1,#(( %2 >> 8 ) ^ 0x80)
1720 } by {
1721         ;       Peephole 213.a  inserted fix
1722         mov     %1,#(%2 >> 8)
1723         xrl     %1,#0x80
1724 }
1725
1726 replace {
1727         mov     %1,#(( %2 + %3 >> 8 ) ^ 0x80)
1728 } by {
1729         ;       Peephole 213.b  inserted fix
1730         mov     %1,#((%2 + %3) >> 8)
1731         xrl     %1,#0x80
1732 }
1733
1734
1735 replace  {
1736         mov     %1,a
1737         mov     a,%2
1738         add     a,%1
1739 } by {
1740         ;       Peephole 214    reduced some extra moves
1741         mov     %1,a
1742         add     a,%2
1743 } if operandsNotSame
1744
1745 replace {
1746         mov     %1,a
1747         add     a,%2
1748         mov     %1,a
1749 } by {
1750         ;       Peephole 215    removed some moves
1751         add     a,%2
1752         mov     %1,a
1753 } if operandsNotSame
1754
1755 replace {
1756         mov     r%1,%2
1757         clr     a
1758         inc     r%1
1759         mov     @r%1,a
1760         dec     r%1
1761         mov     @r%1,a
1762 } by {
1763         ;       Peephole 216    simplified clear (2bytes)
1764         mov     r%1,%2
1765         clr     a
1766         mov     @r%1,a
1767         inc     r%1
1768         mov     @r%1,a
1769 }
1770
1771 replace {
1772         mov     r%1,%2
1773         clr     a
1774         inc     r%1
1775         inc     r%1
1776         mov     @r%1,a
1777         dec     r%1
1778         mov     @r%1,a
1779         dec     r%1
1780         mov     @r%1,a
1781 } by {
1782         ;       Peephole 217    simplified clear (3bytes)
1783         mov     r%1,%2
1784         clr     a
1785         mov     @r%1,a
1786         inc     r%1
1787         mov     @r%1,a
1788         inc     r%1
1789         mov     @r%1,a
1790 }
1791
1792 replace {
1793         mov     r%1,%2
1794         clr     a
1795         inc     r%1
1796         inc     r%1
1797         inc     r%1
1798         mov     @r%1,a
1799         dec     r%1
1800         mov     @r%1,a
1801         dec     r%1
1802         mov     @r%1,a
1803         dec     r%1
1804         mov     @r%1,a
1805 } by {
1806         ;       Peephole 218    simplified clear (4bytes)
1807         mov     r%1,%2
1808         clr     a
1809         mov     @r%1,a
1810         inc     r%1
1811         mov     @r%1,a
1812         inc     r%1
1813         mov     @r%1,a
1814         inc     r%1
1815         mov     @r%1,a
1816 }
1817
1818 replace {
1819         clr     a
1820         movx    @dptr,a
1821         mov     dptr,%1
1822         clr     a
1823         movx    @dptr,a
1824 } by {
1825         ;       Peephole 219    removed redundant clear
1826         clr     a
1827         movx    @dptr,a
1828         mov     dptr,%1
1829         movx    @dptr,a
1830 }
1831
1832 replace {
1833         clr     a
1834         movx    @dptr,a
1835         mov     dptr,%1
1836         movx    @dptr,a
1837         mov     dptr,%2
1838         clr     a
1839         movx    @dptr,a
1840 } by {
1841         ;       Peephole 219.a  removed redundant clear
1842         clr     a
1843         movx    @dptr,a
1844         mov     dptr,%1
1845         movx    @dptr,a
1846         mov     dptr,%2
1847         movx    @dptr,a
1848 }
1849
1850 replace {
1851         mov     dps,#0x00
1852         mov     dps,#0x01
1853 } by {
1854         ;       Peephole 220.a  removed bogus DPS set
1855         mov     dps,#0x01
1856 }
1857
1858 replace {
1859         mov     dps,#0x01
1860         mov     dps,#0x00
1861 } by {
1862         ;       Peephole 220.b  removed bogus DPS set
1863         mov     dps,#0x00
1864 }
1865
1866 replace {
1867         mov     %1 + %2,(%2 + %1)
1868 } by {
1869         ;       Peephole 221.a  remove redundant move
1870 } if notVolatile
1871
1872 replace {
1873         mov     (%1 + %2 + %3),((%2 + %1) + %3)
1874 } by {
1875         ;       Peephole 221.b  remove redundant move
1876 } if notVolatile
1877
1878 replace {
1879         dec     r%1
1880         inc     r%1
1881 } by {
1882         ;       Peephole 222    removed dec/inc pair
1883 }
1884
1885 replace {
1886         mov     %1,dpl
1887         mov     %2,dph
1888         mov     dpl,%1
1889         mov     dph,%2
1890 } by {
1891         ;       Peephole 223    removed redundant dph/dpl moves
1892         mov     %1,dpl
1893         mov     %2,dph
1894 } if notVolatile %1 %2
1895
1896 replace {
1897         mov     %1,dpl
1898         mov     (%1 + 1),dph
1899         mov     dpl,%1
1900         mov     dph,(%1 + 1)
1901 } by {
1902         ;       Peephole 224    removed redundant dph/dpl moves
1903         mov     %1,dpl
1904         mov     (%1 + 1),dph
1905 } if notVolatile %1
1906
1907 replace {
1908         mov     a,%1
1909         movx    @dptr,a
1910         mov     dpl,%2
1911         mov     dph,%3
1912         mov     b,%4
1913         mov     a,%1
1914 } by {
1915         ;       Peephole 225    removed redundant move to acc
1916         mov     a,%1
1917         movx    @dptr,a
1918         mov     dpl,%2
1919         mov     dph,%3
1920         mov     b,%4
1921 } if notVolatile %1
1922
1923 replace {
1924         clr     a
1925         movx    @dptr,a
1926         inc     dptr
1927         movx    @dptr,a
1928         inc     dptr
1929         clr     a
1930 } by {
1931         ;       Peephole 226    removed unnecessary clr
1932         clr     a
1933         movx    @dptr,a
1934         inc     dptr
1935         movx    @dptr,a
1936         inc     dptr
1937 }
1938
1939 replace {
1940         mov     dptr,#%1
1941         clr     a
1942         inc     dptr
1943         inc     dptr
1944         inc     dptr
1945         movx    @dptr,a
1946         lcall   __decdptr
1947         movx    @dptr,a
1948         lcall   __decdptr
1949         movx    @dptr,a
1950         lcall   __decdptr
1951         movx    @dptr,a
1952 } by {
1953         ;       Peephole 227    replaced inefficient 32 bit clear
1954         mov     dptr,#%1
1955         clr     a
1956         movx    @dptr,a
1957         inc     dptr
1958         movx    @dptr,a
1959         inc     dptr
1960         movx    @dptr,a
1961         inc     dptr
1962         movx    @dptr,a
1963         mov     dptr,#%1
1964 }
1965
1966 replace {
1967         mov     dptr,#%1
1968         clr     a
1969         inc     dptr
1970         inc     dptr
1971         inc     dptr
1972         movx    @dptr,a
1973         lcall   __decdptr
1974         movx    @dptr,a
1975         lcall   __decdptr
1976         movx    @dptr,a
1977         lcall   __decdptr
1978         mov     a,#%2
1979         movx    @dptr,a
1980 } by {
1981         ;       Peephole 228    replaced inefficient 32 constant
1982         mov     dptr,#%1
1983         mov     a,#%2
1984         movx    @dptr,a
1985         inc     dptr
1986         clr     a
1987         movx    @dptr,a
1988         inc     dptr
1989         movx    @dptr,a
1990         inc     dptr
1991         movx    @dptr,a
1992         mov     dptr,#%1
1993 }
1994
1995 replace {
1996         mov     dptr,#%1
1997         clr     a
1998         inc     dptr
1999         movx    @dptr,a
2000         lcall   __decdptr
2001         movx    @dptr,a
2002 } by {
2003         ;       Peephole 229    replaced inefficient 16 bit clear
2004         mov     dptr,#%1
2005         clr     a
2006         movx    @dptr,a
2007         inc     dptr
2008         movx    @dptr,a
2009         mov     dptr,#%1
2010 }
2011
2012 replace {
2013         mov     dptr,#%1
2014         clr     a
2015         inc     dptr
2016         movx    @dptr,a
2017         lcall   __decdptr
2018         mov     a,#%2
2019         movx    @dptr,a
2020 } by {
2021         ;       Peephole 230    replaced inefficient 16 bit constant
2022         mov     dptr,#%1
2023         mov     a,#%2
2024         movx    @dptr,a
2025         inc     dptr
2026         clr     a
2027         movx    @dptr,a
2028         mov     dptr,#%1
2029 }
2030
2031 // this last peephole often removes the last mov from 227-230
2032 replace {
2033         mov     dptr,#%1
2034         mov     dptr,#%2
2035 } by {
2036         ;       Peephole 231    removed redundant mov to dptr
2037         mov     dptr,#%2
2038 }
2039
2040 replace {
2041         movx    a,@dptr
2042 } by {
2043         ;       Peephole 232    using movc to read xdata (--xram-movc)
2044         clr     a
2045         movc    a,@a+dptr
2046 } if xramMovcOption
2047
2048 replace {
2049         lcall   _gptrget
2050 } by {
2051         ;       Peephole 233    using _gptrgetc instead of _gptrget (--xram-movc)
2052         lcall   _gptrgetc
2053 } if xramMovcOption
2054
2055 replace {
2056         mov     r%1,a
2057         mov     dpl,r%1
2058 %2:
2059         ret
2060 } by {
2061         ;       Peephole 234    loading dpl directly from a(ccumulator), r%1 not set
2062         mov     dpl,a
2063 %2:
2064         ret
2065 }
2066
2067 replace {
2068         mov     r%1,a
2069         mov     dpl,r%2
2070         mov     dph,r%1
2071 %3:
2072         ret
2073 } by {
2074         ;       Peephole 235    loading dph directly from a(ccumulator), r%1 not set
2075         mov     dpl,r%2
2076         mov     dph,a
2077 %3:
2078         ret
2079 }
2080
2081 // 14 rules by Fiorenzo D. Ramaglia <fd.ramaglia@tin.it>
2082
2083 replace {
2084         add     a,ar%1
2085 } by {
2086         ;       Peephole 236.a  used r%1 instead of ar%1
2087         add     a,r%1
2088 }
2089
2090 replace {
2091         addc    a,ar%1
2092 } by {
2093         ;       Peephole 236.b  used r%1 instead of ar%1
2094         addc    a,r%1
2095 }
2096
2097 replace {
2098         anl     a,ar%1
2099 } by {
2100         ;       Peephole 236.c  used r%1 instead of ar%1
2101         anl     a,r%1
2102 }
2103
2104 replace {
2105         dec     ar%1
2106 } by {
2107         ;       Peephole 236.d  used r%1 instead of ar%1
2108         dec     r%1
2109 }
2110
2111 replace {
2112         djnz    ar%1,%2
2113 } by {
2114         ;       Peephole 236.e  used r%1 instead of ar%1
2115         djnz    r%1,%2
2116 }
2117
2118 replace {
2119         inc     ar%1
2120 } by {
2121         ;       Peephole 236.f  used r%1 instead of ar%1
2122         inc     r%1
2123 }
2124
2125 replace {
2126         mov     a,ar%1
2127 } by {
2128         ;       Peephole 236.g  used r%1 instead of ar%1
2129         mov     a,r%1
2130 }
2131
2132 replace {
2133         mov     ar%1,#%2
2134 } by {
2135         ;       Peephole 236.h  used r%1 instead of ar%1
2136         mov     r%1,#%2
2137 }
2138
2139 replace {
2140         mov     ar%1,a
2141 } by {
2142         ;       Peephole 236.i  used r%1 instead of ar%1
2143         mov     r%1,a
2144 }
2145
2146 replace {
2147         mov     ar%1,ar%2
2148 } by {
2149         ;       Peephole 236.j  used r%1 instead of ar%1
2150         mov     r%1,ar%2
2151 }
2152
2153 replace {
2154         orl     a,ar%1
2155 } by {
2156         ;       Peephole 236.k  used r%1 instead of ar%1
2157         orl     a,r%1
2158 }
2159
2160 replace {
2161         subb    a,ar%1
2162 } by {
2163         ;       Peephole 236.l  used r%1 instead of ar%1
2164         subb    a,r%1
2165 }
2166
2167 replace {
2168         xch     a,ar%1
2169 } by {
2170         ;       Peephole 236.m  used r%1 instead of ar%1
2171         xch     a,r%1
2172 }
2173
2174 replace {
2175         xrl     a,ar%1
2176 } by {
2177         ;       Peephole 236.n  used r%1 instead of ar%1
2178         xrl     a,r%1
2179 }
2180
2181 replace {
2182         sjmp    %1
2183 %2:
2184         mov     %3,%4
2185 %1:
2186         ret
2187 } by {
2188         ;       Peephole 237.a  removed sjmp to ret
2189         ret
2190 %2:
2191         mov     %3,%4
2192 %1:
2193         ret
2194 }
2195
2196 replace {
2197         sjmp    %1
2198 %2:
2199         mov     %3,%4
2200         mov     dpl,%5
2201         mov     dph,%6
2202 %1:
2203         ret
2204 } by {
2205         ;       Peephole 237.b  removed sjmp to ret
2206         ret
2207 %2:
2208         mov     %3,%4
2209         mov     dpl,%5
2210         mov     dph,%6
2211 %1:
2212         ret
2213 }
2214
2215 // applies to f.e. device/lib/log10f.c
2216 replace {
2217         mov     %1,%9
2218         mov     %2,%10
2219         mov     %3,%11
2220         mov     %4,%12
2221
2222         mov     %5,%13
2223         mov     %6,%14
2224         mov     %7,%15
2225         mov     %8,%16
2226
2227         mov     %9,%1
2228         mov     %10,%2
2229         mov     %11,%3
2230         mov     %12,%4
2231 } by {
2232         mov     %1,%9
2233         mov     %2,%10
2234         mov     %3,%11
2235         mov     %4,%12
2236
2237         mov     %5,%13
2238         mov     %6,%14
2239         mov     %7,%15
2240         mov     %8,%16
2241         ;       Peephole 238.a  removed 4 redundant moves
2242 } if operandsNotSame8 %1 %2 %3 %4 %5 %6 %7 %8
2243
2244 // applies to device/lib/log10f.c
2245 replace {
2246         mov     %1,%5
2247         mov     %2,%6
2248         mov     %3,%7
2249         mov     %4,%8
2250
2251         mov     %5,%1
2252         mov     %6,%2
2253         mov     %7,%3
2254 } by {
2255         mov     %1,%5
2256         mov     %2,%6
2257         mov     %3,%7
2258         mov     %4,%8
2259         ;       Peephole 238.b  removed 3 redundant moves
2260 } if operandsNotSame7 %1 %2 %3 %4 %5 %6 %7
2261
2262 // applies to f.e. device/lib/time.c
2263 replace {
2264         mov     %1,%5
2265         mov     %2,%6
2266
2267         mov     %3,%7
2268         mov     %4,%8
2269
2270         mov     %5,%1
2271         mov     %6,%2
2272 } by {
2273         mov     %1,%5
2274         mov     %2,%6
2275
2276         mov     %3,%7
2277         mov     %4,%8
2278         ;       Peephole 238.c  removed 2 redundant moves
2279 } if operandsNotSame4 %1 %2 %3 %4
2280
2281 // applies to f.e. support/regression/tests/bug-524209.c
2282 replace {
2283         mov     %1,%4
2284         mov     %2,%5
2285         mov     %3,%6
2286
2287         mov     %4,%1
2288         mov     %5,%2
2289         mov     %6,%3
2290 } by {
2291         mov     %1,%4
2292         mov     %2,%5
2293         mov     %3,%6
2294         ;       Peephole 238.d  removed 3 redundant moves
2295 } if operandsNotSame6 %1 %2 %3 %4 %5 %6
2296
2297 // applies to f.e. ser_ir.asm
2298 replace {
2299         mov     r%1,acc
2300 } by {
2301         ;       Peephole 239    used a instead of acc
2302         mov     r%1,a
2303 }
2304
2305 replace restart {
2306         mov     a,%1
2307         addc    a,#0x00
2308 } by {
2309         ;       Peephole 240    use clr instead of addc a,#0
2310         clr     a
2311         addc    a,%1
2312 }
2313
2314 // peepholes 241.a to 241.c and 241.d to 241.f need to be in order
2315 replace {
2316         cjne    r%1,#%2,%3
2317         cjne    r%4,#%5,%3
2318         cjne    r%6,#%7,%3
2319         cjne    r%8,#%9,%3
2320         mov     a,#0x01
2321         sjmp    %10
2322 %3:
2323         clr     a
2324 %10:
2325 } by {
2326         ;       Peephole 241.a  optimized compare
2327         clr     a
2328         cjne    r%1,#%2,%3
2329         cjne    r%4,#%5,%3
2330         cjne    r%6,#%7,%3
2331         cjne    r%8,#%9,%3
2332         inc     a
2333 %3:
2334 %10:
2335 }
2336
2337 // applies to f.e. time.c
2338 replace {
2339         cjne    r%1,#%2,%3
2340         cjne    r%4,#%5,%3
2341         mov     a,#0x01
2342         sjmp    %6
2343 %3:
2344         clr     a
2345 %6:
2346 } by {
2347         ;       Peephole 241.b  optimized compare
2348         clr     a
2349         cjne    r%1,#%2,%3
2350         cjne    r%4,#%5,%3
2351         inc     a
2352 %3:
2353 %6:
2354 }
2355
2356 // applies to f.e. malloc.c
2357 replace {
2358         cjne    r%1,#%2,%3
2359         mov     a,#0x01
2360         sjmp    %4
2361 %3:
2362         clr     a
2363 %4:
2364 } by {
2365         ;       Peephole 241.c  optimized compare
2366         clr     a
2367         cjne    r%1,#%2,%3
2368         inc     a
2369 %3:
2370 %4:
2371 }
2372
2373 // applies to f.e. j = (k!=0x1000);
2374 // with volatile idata long k;
2375 replace {
2376         cjne    @r%1,#%2,%3
2377         inc     r%1
2378         cjne    @r%1,#%4,%3
2379         inc     r%1
2380         cjne    @r%1,#%5,%3
2381         inc     r%1
2382         cjne    @r%1,#%6,%3
2383         mov     a,#0x01
2384         sjmp    %7
2385 %3:
2386         clr     a
2387 %7:
2388 } by {
2389         ;       Peephole 241.d  optimized compare
2390         clr     a
2391         cjne    @r%1,#%2,%3
2392         inc     r%1
2393         cjne    @r%1,#%4,%3
2394         inc     r%1
2395         cjne    @r%1,#%5,%3
2396         inc     r%1
2397         cjne    @r%1,#%6,%3
2398         inc     a
2399 %3:
2400 %7:
2401 }
2402
2403 // applies to f.e. j = (k!=0x1000);
2404 // with volatile idata int k;
2405 replace {
2406         cjne    @r%1,#%2,%3
2407         inc     r%1
2408         cjne    @r%1,#%4,%3
2409         mov     a,#0x01
2410         sjmp    %7
2411 %3:
2412         clr     a
2413 %7:
2414 } by {
2415         ;       Peephole 241.e  optimized compare
2416         clr     a
2417         cjne    @r%1,#%2,%3
2418         inc     r%1
2419         cjne    @r%1,#%4,%3
2420         inc     a
2421 %3:
2422 %7:
2423 }
2424
2425 // applies to f.e. vprintf.asm (--stack-auto)
2426 replace {
2427         cjne    @r%1,#%2,%3
2428         mov     a,#0x01
2429         sjmp    %7
2430 %3:
2431         clr     a
2432 %7:
2433 } by {
2434         ;       Peephole 241.f  optimized compare
2435         clr     a
2436         cjne    @r%1,#%2,%3
2437         inc     a
2438 %3:
2439 %7:
2440 }
2441
2442 // applies to f.e. scott-bool1.c
2443 replace {
2444         jnz     %1
2445         mov     %2,%3
2446 %1:
2447         jz      %4
2448 } by {
2449         ;       Peephole 242.a  avoided branch jnz to jz
2450         jnz     %1
2451         mov     %2,%3
2452         jz      %4
2453 %1:
2454 } if labelRefCount %1 1
2455
2456 // applies to f.e. scott-bool1.c
2457 replace {
2458         jnz     %1
2459         mov     %2,%3
2460         orl     a,%5
2461 %1:
2462         jz      %4
2463 } by {
2464         ;       Peephole 242.b  avoided branch jnz to jz
2465         jnz     %1
2466         mov     %2,%3
2467         orl     a,%5
2468         jz      %4
2469 %1:
2470 } if labelRefCount %1 1
2471
2472 // applies to f.e. logic.c
2473 replace {
2474         jnz     %1
2475         mov     %2,%3
2476         orl     a,%5
2477         orl     a,%6
2478         orl     a,%7
2479 %1:
2480         jz      %4
2481 } by {
2482         ;       Peephole 242.c  avoided branch jnz to jz
2483         jnz     %1
2484         mov     %2,%3
2485         orl     a,%5
2486         orl     a,%6
2487         orl     a,%7
2488         jz      %4
2489 %1:
2490 } if labelRefCount %1 1
2491
2492 // applies to f.e. vprintf.c
2493 // this is a rare case, usually the "tail increment" is noticed earlier
2494 replace {
2495         cjne    %1,%2,%3
2496         inc     %4
2497 %3:
2498         sjmp    %5
2499 } by {
2500         ;       Peephole 243    avoided branch to sjmp
2501         cjne    %1,%2,%5
2502         inc     %4
2503 %3:
2504         sjmp    %5
2505 } if labelInRange
2506
2507 // applies to f.e. simplefloat.c (saving 1 cycle)
2508 replace {
2509         mov     r%1,dpl
2510         mov     a,r%1
2511 } by {
2512         ;       Peephole 244.a  moving first to a instead of r%1
2513         mov     a,dpl
2514         mov     r%1,a
2515 }
2516
2517 // applies to f.e. _itoa.c (saving 1 cycle)
2518 replace {
2519         mov     r%1,dph
2520         mov     a,r%1
2521 } by {
2522         ;       Peephole 244.b  moving first to a instead of r%1
2523         mov     a,dph
2524         mov     r%1,a
2525 }
2526
2527
2528 // applies to f.e. bug-460010.c (saving 1 cycle)
2529 replace {
2530         mov     r%1,a
2531         mov     dpl,r%1
2532 } by {
2533         ;       Peephole 244.c  loading dpl from a instead of r%1
2534         mov     r%1,a
2535         mov     dpl,a
2536 }
2537
2538 replace {
2539         mov     r%1,a
2540         mov     dph,r%1
2541 } by {
2542         ;       Peephole 244.d  loading dph from a instead of r%1
2543         mov     r%1,a
2544         mov     dph,a
2545 }
2546
2547 // this one is safe but disables 245.a 245.b
2548 // please remove 245 if 245.a 245.b are found to be safe
2549 // applies to f.e. scott-compare.c
2550 replace {
2551         clr     a
2552         rlc     a
2553         mov     r%1,a
2554         cjne    a,#0x01,%2
2555 %2:
2556         clr     a
2557         rlc     a
2558         mov     r%1,a
2559 } by {
2560         ;       Peephole 245    optimized complement (r%1 and acc set needed?)
2561         cpl     c
2562         clr     a
2563         rlc     a
2564         mov     r%1,a
2565 } if labelRefCount %2 1
2566
2567 // this one will not be triggered if 245 is present
2568 // please remove 245 if 245.a 245.b are found to be safe
2569 // applies to f.e. vprintf.c
2570 replace {
2571         clr     a
2572         rlc     a
2573         mov     r%1,a
2574         cjne    a,#0x01,%2
2575 %2:
2576         clr     a
2577         rlc     a
2578         mov     r%1,a
2579         jz      %3
2580 } by {
2581         ;       Peephole 245.a  optimized conditional jump (r%1 and acc not set!)
2582         jc      %3
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. scott-compare.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         jnz     %3
2598 } by {
2599         ;       Peephole 245.b  optimized conditional jump (r%1 and acc not set!)
2600         jnc     %3
2601 } if labelRefCount %2 1
2602
2603
2604 // rules 246.x apply to f.e. bitfields.c
2605 replace {
2606         mov     dptr,#%1
2607         movx    a,@dptr
2608         anl     a,#%2
2609         movx    @dptr,a
2610         mov     dptr,#%1
2611         movx    a,@dptr
2612         anl     a,#%3
2613         movx    @dptr,a
2614 } by {
2615         ;       Peephole 246.a  combined clr/clr
2616         mov     dptr,#%1
2617         movx    a,@dptr
2618         anl     a,#%2&%3
2619         movx    @dptr,a
2620 } if notVolatile %1
2621
2622 replace {
2623         mov     dptr,#%1
2624         movx    a,@dptr
2625         orl     a,#%2
2626         movx    @dptr,a
2627         mov     dptr,#%1
2628         movx    a,@dptr
2629         orl     a,#%3
2630         movx    @dptr,a
2631 } by {
2632         ;       Peephole 246.b  combined set/set
2633         mov     dptr,#%1
2634         movx    a,@dptr
2635         orl     a,#%2|%3
2636         movx    @dptr,a
2637 } if notVolatile %1
2638
2639 replace {
2640         mov     dptr,#%1
2641         movx    a,@dptr
2642         orl     a,#%2
2643         movx    @dptr,a
2644         mov     dptr,#%1
2645         movx    a,@dptr
2646         anl     a,#%3
2647         movx    @dptr,a
2648 } by {
2649         ;       Peephole 246.c  combined set/clr
2650         mov     dptr,#%1
2651         movx    a,@dptr
2652         orl     a,#%2
2653         anl     a,#%3
2654         movx    @dptr,a
2655 } if notVolatile %1
2656
2657 replace {
2658         mov     dptr,#%1
2659         movx    a,@dptr
2660         anl     a,#%2
2661         movx    @dptr,a
2662         mov     dptr,#%1
2663         movx    a,@dptr
2664         orl     a,#%3
2665         movx    @dptr,a
2666 } by {
2667         ;       Peephole 246.d  combined clr/set
2668         mov     dptr,#%1
2669         movx    a,@dptr
2670         anl     a,#%2
2671         orl     a,#%3
2672         movx    @dptr,a
2673 } if notVolatile %1
2674
2675 replace {
2676         mov     dptr,#%1
2677         movx    a,@dptr
2678         orl     a,#%2
2679         anl     a,#%3
2680         movx    @dptr,a
2681         mov     dptr,#%1
2682         movx    a,@dptr
2683         anl     a,#%4
2684         movx    @dptr,a
2685 } by {
2686         ;       Peephole 246.e  combined set/clr/clr
2687         mov     dptr,#%1
2688         movx    a,@dptr
2689         orl     a,#%2
2690         anl     a,#%3&%4
2691         movx    @dptr,a
2692 } if notVolatile %1
2693
2694 replace {
2695         mov     dptr,#%1
2696         movx    a,@dptr
2697         orl     a,#%2
2698         anl     a,#%3
2699         movx    @dptr,a
2700         mov     dptr,#%1
2701         movx    a,@dptr
2702         orl     a,#%4
2703         movx    @dptr,a
2704 } by {
2705         ;       Peephole 246.f  combined set/clr/set
2706         mov     dptr,#%1
2707         movx    a,@dptr
2708         orl     a,#%2
2709         anl     a,#%3
2710         orl     a,#%4
2711         movx    @dptr,a
2712 } if notVolatile %1
2713
2714 replace {
2715         mov     dptr,#%1
2716         movx    a,@dptr
2717         anl     a,#%2
2718         orl     a,#%3
2719         movx    @dptr,a
2720         mov     dptr,#%1
2721         movx    a,@dptr
2722         anl     a,#%4
2723         movx    @dptr,a
2724 } by {
2725         ;       Peephole 246.g  combined clr/set/clr
2726         mov     dptr,#%1
2727         movx    a,@dptr
2728         anl     a,#%2
2729         orl     a,#%3
2730         anl     a,#%4
2731         movx    @dptr,a
2732 } if notVolatile %1
2733
2734 replace {
2735         mov     dptr,#%1
2736         movx    a,@dptr
2737         anl     a,#%2
2738         orl     a,#%3
2739         movx    @dptr,a
2740         mov     dptr,#%1
2741         movx    a,@dptr
2742         orl     a,#%4
2743         movx    @dptr,a
2744 } by {
2745         ;       Peephole 246.h  combined clr/set/set
2746         mov     dptr,#%1
2747         movx    a,@dptr
2748         anl     a,#%2
2749         orl     a,#%3|%4
2750         movx    @dptr,a
2751 } if notVolatile %1
2752
2753
2754
2755
2756 // rules 247.x apply to f.e. bitfields.c
2757 replace {
2758         mov     r%5,#%1
2759         mov     a,@r%5
2760         anl     a,#%2
2761         mov     @r%5,a
2762         mov     r%5,#%1
2763         mov     a,@r%5
2764         anl     a,#%3
2765         mov     @r%5,a
2766 } by {
2767         ;       Peephole 247.a  combined clr/clr
2768         mov     r%5,#%1
2769         mov     a,@r%5
2770         anl     a,#%2&%3
2771         mov     @r%5,a
2772 } if notVolatile %1
2773
2774 replace {
2775         mov     r%5,#%1
2776         mov     a,@r%5
2777         orl     a,#%2
2778         mov     @r%5,a
2779         mov     r%5,#%1
2780         mov     a,@r%5
2781         orl     a,#%3
2782         mov     @r%5,a
2783 } by {
2784         ;       Peephole 247.b  combined set/set
2785         mov     r%5,#%1
2786         mov     a,@r%5
2787         orl     a,#%2|%3
2788         mov     @r%5,a
2789 } if notVolatile %1
2790
2791 replace {
2792         mov     r%5,#%1
2793         mov     a,@r%5
2794         orl     a,#%2
2795         mov     @r%5,a
2796         mov     r%5,#%1
2797         mov     a,@r%5
2798         anl     a,#%3
2799         mov     @r%5,a
2800 } by {
2801         ;       Peephole 247.c  combined set/clr
2802         mov     r%5,#%1
2803         mov     a,@r%5
2804         orl     a,#%2
2805         anl     a,#%3
2806         mov     @r%5,a
2807 } if notVolatile %1
2808
2809 replace {
2810         mov     r%5,#%1
2811         mov     a,@r%5
2812         anl     a,#%2
2813         mov     @r%5,a
2814         mov     r%5,#%1
2815         mov     a,@r%5
2816         orl     a,#%3
2817         mov     @r%5,a
2818 } by {
2819         ;       Peephole 247.d  combined clr/set
2820         mov     r%5,#%1
2821         mov     a,@r%5
2822         anl     a,#%2
2823         orl     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         orl     a,#%2
2831         anl     a,#%3
2832         mov     @r%5,a
2833         mov     r%5,#%1
2834         mov     a,@r%5
2835         anl     a,#%4
2836         mov     @r%5,a
2837 } by {
2838         ;       Peephole 247.e  combined set/clr/clr
2839         mov     r%5,#%1
2840         mov     a,@r%5
2841         orl     a,#%2
2842         anl     a,#%3&%4
2843         mov     @r%5,a
2844 } if notVolatile %1
2845
2846 replace {
2847         mov     r%5,#%1
2848         mov     a,@r%5
2849         orl     a,#%2
2850         anl     a,#%3
2851         mov     @r%5,a
2852         mov     r%5,#%1
2853         mov     a,@r%5
2854         orl     a,#%4
2855         mov     @r%5,a
2856 } by {
2857         ;       Peephole 247.f  combined set/clr/set
2858         mov     r%5,#%1
2859         mov     a,@r%5
2860         orl     a,#%2
2861         anl     a,#%3
2862         orl     a,#%4
2863         mov     @r%5,a
2864 } if notVolatile %1
2865
2866 replace {
2867         mov     r%5,#%1
2868         mov     a,@r%5
2869         anl     a,#%2
2870         orl     a,#%3
2871         mov     @r%5,a
2872         mov     r%5,#%1
2873         mov     a,@r%5
2874         anl     a,#%4
2875         mov     @r%5,a
2876 } by {
2877         ;       Peephole 247.g  combined clr/set/clr
2878         mov     r%5,#%1
2879         mov     a,@r%5
2880         anl     a,#%2
2881         orl     a,#%3
2882         anl     a,#%4
2883         mov     @r%5,a
2884 } if notVolatile %1
2885
2886 replace {
2887         mov     r%5,#%1
2888         mov     a,@r%5
2889         anl     a,#%2
2890         orl     a,#%3
2891         mov     @r%5,a
2892         mov     r%5,#%1
2893         mov     a,@r%4
2894         orl     a,#%4
2895         mov     @r%5,a
2896 } by {
2897         ;       Peephole 247.h  combined clr/set/set
2898         mov     r%5,#%1
2899         mov     a,@r%5
2900         anl     a,#%2
2901         orl     a,#%3|%4
2902         mov     @r%5,a
2903 } if notVolatile %1
2904
2905
2906 // Peepholes 248.x have to be compatible with the keyword volatile.
2907 // They optimize typical accesses to memory mapped I/O devices:
2908 // volatile xdata char t; t|=0x01;
2909 replace {
2910         mov     dptr,%1
2911         movx    a,@dptr
2912         mov     r%2,a
2913         mov     dptr,%1
2914         mov     a,%3
2915         orl     a,r%2
2916         movx    @dptr,a
2917 } by {
2918         ;       Peephole 248.a  optimized or to xdata
2919         mov     dptr,%1
2920         movx    a,@dptr
2921         mov     r%2,a
2922         orl     a,%3
2923         movx    @dptr,a
2924 }
2925
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         anl     a,r%2
2934         movx    @dptr,a
2935 } by {
2936         ;       Peephole 248.b  optimized and to xdata
2937         mov     dptr,%1
2938         movx    a,@dptr
2939         mov     r%2,a
2940         anl     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         xrl     a,r%2
2952         movx    @dptr,a
2953 } by {
2954         ;       Peephole 248.c  optimized xor to xdata
2955         mov     dptr,%1
2956         movx    a,@dptr
2957         mov     r%2,a
2958         xrl     a,%3
2959         movx    @dptr,a
2960 }
2961
2962 // volatile xdata char t; t|=0x01; t&=~0x01; t|=0x01;
2963 replace {
2964         mov     dptr,%1
2965         movx    a,@dptr
2966         mov     r%2,a
2967         orl     a,%3
2968         movx    @dptr,a
2969
2970         mov     dptr,%1
2971         movx    a,@dptr
2972         mov     r%2,a
2973         anl     a,%4
2974         movx    @dptr,a
2975
2976         mov     dptr,%1
2977         movx    a,@dptr
2978         mov     r%2,a
2979         orl     a,%5
2980         movx    @dptr,a
2981 } by {
2982         ;       Peephole 248.d  optimized or/and/or to volatile xdata
2983         mov     dptr,%1
2984         movx    a,@dptr
2985         orl     a,%3
2986         movx    @dptr,a
2987         movx    a,@dptr
2988         anl     a,%4
2989         movx    @dptr,a
2990         movx    a,@dptr
2991         mov     r%2,a
2992         orl     a,%5
2993         movx    @dptr,a
2994 }
2995
2996 // volatile xdata char t; t&=~0x01; t|=0x01; t&=~0x01;
2997 replace {
2998         mov     dptr,%1
2999         movx    a,@dptr
3000         mov     r%2,a
3001         anl     a,%3
3002         movx    @dptr,a
3003
3004         mov     dptr,%1
3005         movx    a,@dptr
3006         mov     r%2,a
3007         orl     a,%4
3008         movx    @dptr,a
3009
3010         mov     dptr,%1
3011         movx    a,@dptr
3012         mov     r%2,a
3013         anl     a,%5
3014         movx    @dptr,a
3015 } by {
3016         ;       Peephole 248.e  optimized and/or/and to volatile xdata
3017         mov     dptr,%1
3018         movx    a,@dptr
3019         anl     a,%3
3020         movx    @dptr,a
3021         movx    a,@dptr
3022         orl     a,%4
3023         movx    @dptr,a
3024         movx    a,@dptr
3025         mov     r%2,a
3026         anl     a,%5
3027         movx    @dptr,a
3028 }
3029
3030 // volatile xdata char t; t|=0x01; t&=~0x01;
3031 replace {
3032         mov     dptr,%1
3033         movx    a,@dptr
3034         mov     r%2,a
3035         orl     a,%3
3036         movx    @dptr,a
3037
3038         mov     dptr,%1
3039         movx    a,@dptr
3040         mov     r%2,a
3041         anl     a,%4
3042         movx    @dptr,a
3043 } by {
3044         ;       Peephole 248.f  optimized or/and to volatile xdata
3045         mov     dptr,%1
3046         movx    a,@dptr
3047         orl     a,%3
3048         movx    @dptr,a
3049         movx    a,@dptr
3050         mov     r%2,a
3051         anl     a,%4
3052         movx    @dptr,a
3053 }
3054
3055 // volatile xdata char t; t&=~0x01; t|=0x01;
3056 replace {
3057         mov     dptr,%1
3058         movx    a,@dptr
3059         mov     r%2,a
3060         anl     a,%3
3061         movx    @dptr,a
3062
3063         mov     dptr,%1
3064         movx    a,@dptr
3065         mov     r%2,a
3066         orl     a,%4
3067         movx    @dptr,a
3068 } by {
3069         ;       Peephole 248.g  optimized and/or to volatile xdata
3070         mov     dptr,%1
3071         movx    a,@dptr
3072         anl     a,%3
3073         movx    @dptr,a
3074         movx    a,@dptr
3075         mov     r%2,a
3076         orl     a,%4
3077         movx    @dptr,a
3078 }
3079
3080 // volatile xdata char t; t^=0x01; t^=0x01;
3081 replace {
3082         mov     dptr,%1
3083         movx    a,@dptr
3084         mov     r%2,a
3085         xrl     a,%3
3086         movx    @dptr,a
3087
3088         mov     dptr,%1
3089         movx    a,@dptr
3090         mov     r%2,a
3091         xrl     a,%4
3092         movx    @dptr,a
3093 } by {
3094         ;       Peephole 248.h  optimized xor/xor to volatile xdata
3095         mov     dptr,%1
3096         movx    a,@dptr
3097         xrl     a,%3
3098         movx    @dptr,a
3099         movx    a,@dptr
3100         mov     r%2,a
3101         xrl     a,%4
3102         movx    @dptr,a
3103 }
3104
3105 replace {
3106         jnz     %1
3107 %1:
3108 } by {
3109         ;       Peephole 249.a   jump optimization
3110 } if labelRefCount %1 1
3111
3112 replace {
3113         jz      %1
3114 %1:
3115 } by {
3116         ;       Peephole 249.b   jump optimization
3117 } if labelRefCount %1 1
3118
3119
3120 // This allows non-interrupt and interrupt code to safely compete
3121 // for a resource without the non-interrupt code having to disable
3122 // interrupts:
3123 // volatile bit resource_is_free;
3124 // if( resource_is_free ) {
3125 //     resource_is_free=0; do_something; resource_is_free=1;
3126 // }
3127 replace {
3128         jnb     %1,%2
3129 %3:
3130         clr     %1
3131 } by {
3132         ;       Peephole 250.a  using atomic test and clear
3133         jbc     %1,%3
3134         sjmp    %2
3135 %3:
3136 } if labelRefCount %3 0
3137
3138 replace {
3139         jb      %1,%2
3140         ljmp    %3
3141 %2:
3142         clr     %1
3143 } by {
3144         ;       Peephole 250.b  using atomic test and clear
3145         jbc     %1,%2
3146         ljmp    %3
3147 %2:
3148 } if labelRefCount %2 1
3149
3150
3151 // not before peephole 250.b
3152 replace {
3153         ljmp    %5
3154 } by {
3155         ;       Peephole 251.a  replaced ljmp to ret with ret
3156         ret
3157 } if labelIsReturnOnly
3158
3159 // not before peephole 250.b
3160 replace {
3161         sjmp    %5
3162 } by {
3163         ;       Peephole 251.b  replaced sjmp to ret with ret
3164         ret
3165 } if labelIsReturnOnly
3166
3167 // applies to shifts.c and when accessing arrays with an unsigned integer index
3168 // saving 1 byte, 2 cycles
3169 replace {
3170         mov     r%1,%2
3171         mov     a,(%2 + 1)
3172         xch     a,r%1
3173         add     a,acc
3174         xch     a,r%1
3175         rlc     a
3176         mov     r%3,a
3177 } by {
3178         ;       Peephole 252    optimized left shift
3179         mov     a,%2
3180         add     a,acc
3181         mov     r%1,a
3182         mov     a,(%2 + 1)
3183         rlc     a
3184         mov     r%3,a
3185 }
3186
3187 // applies to: void test( char c ) { if( c ) func1(); else func2(); }
3188 replace {
3189         lcall   %1
3190         ret
3191 } by {
3192         ;       Peephole 253.a  replaced lcall/ret with ljmp
3193         ljmp    %1
3194 }
3195
3196 // applies to: void test( char c ) { if( c ) func1(); else func2(); }
3197 replace {
3198         lcall   %1
3199 %2:
3200         ret
3201 } by {
3202         ;       Peephole 253.b  replaced lcall/ret with ljmp
3203         ljmp    %1
3204 } if labelRefCount %2 0
3205
3206 // applies to f.e. scott-bool1.c
3207 replace {
3208         lcall   %1
3209 %2:
3210         ret
3211 } by {
3212         ;       Peephole 253.c  replaced lcall with ljmp
3213         ljmp    %1
3214 %2:
3215         ret
3216 }
3217
3218
3219 // applies to f.e. funptrs.c
3220 // saves one byte if %1 is a register or @register
3221 replace {
3222         mov     a,%1
3223         add     a,acc
3224 } by {
3225         ;       Peephole 254    optimized left shift
3226         mov     a,%1
3227         add     a,%1
3228 } if notVolatile %1
3229
3230 // applies to f.e. switch.c
3231 replace {
3232         clr     c
3233         mov     a,#%1
3234         subb    a,%2
3235         jc      %3
3236 %4:
3237         mov     a,%2
3238         add     a,%2
3239         add     a,%2
3240         mov     dptr,%5
3241         jmp     @a+dptr
3242 } by {
3243         ;       Peephole 255    optimized jump table index calculation
3244         mov     a,%2
3245         cjne    a,#(%1+0x01),.+1
3246         jnc     %3
3247 %4:
3248         add     a,%2
3249         add     a,%2
3250         mov     dptr,%5
3251         jmp     @a+dptr
3252 }
3253
3254 // applies to f.e. jump tables and scott-bool1.c.
3255 // similar peepholes can be constructed for other instructions
3256 // after which a flag or a register is known (like: djnz, cjne, jnc)
3257 replace {
3258         jc      %1
3259 %2:
3260         clr     c
3261 } by {
3262         ;       Peephole 256.a  removed redundant clr c
3263         jc      %1
3264 %2:
3265 } if labelRefCount %2 0
3266
3267 // applies to f.e. logf.c
3268 replace {
3269         jnz     %1
3270 %2:
3271         clr     a
3272 } by {
3273         ;       Peephole 256.b  removed redundant clr a
3274         jnz     %1
3275 %2:
3276 } if labelRefCount %2 0
3277
3278
3279 // unsigned char i=8; do{ } while(--i != 0);
3280 // this currently only applies if i is kept in a register
3281 replace {
3282         dec     %1
3283         cjne    %1,#0x00,%2
3284 } by {
3285         ;       Peephole 257    optimized decrement with compare
3286         djnz    %1,%2
3287 } if notVolatile %1
3288
3289
3290 // in_byte<<=1; if(in_bit) in_byte|=1;
3291 // helps f.e. reading data on a 3-wire (SPI) bus
3292 replace {
3293         mov     a,%1
3294         add     a,%1
3295         mov     %1,a
3296         jnb     %2,%3
3297 %4:
3298         orl     %1,#0x01
3299 %3:
3300 } by {
3301         ;       Peephole 258.a  optimized bitbanging
3302         mov     a,%1
3303         mov     c,%2
3304         addc    a,%1
3305         mov     %1,a
3306 %4:
3307 %3:
3308 } if notVolatile %1
3309
3310 // in_byte<<=1; if(in_bit) in_byte|=1;
3311 replace {
3312         mov     a,r%1
3313         add     a,r%1
3314         mov     r%1,a
3315         jnb     %2,%3
3316 %4:
3317         orl     ar%1,#0x01
3318 %3:
3319 } by {
3320         ;       Peephole 258.b  optimized bitbanging
3321         mov     a,r%1
3322         mov     c,%2
3323         addc    a,r%1
3324         mov     r%1,a
3325 %4:
3326 %3:
3327 }
3328
3329 // in_byte>>=1; if(in_bit) in_byte|=0x80;
3330 replace {
3331         mov     a,%1
3332         clr     c
3333         rrc     a
3334         mov     %1,a
3335         jnb     %2,%3
3336 %4:
3337         orl     %1,#0x80
3338 %3:
3339 } by {
3340         ;       Peephole 258.c  optimized bitbanging
3341         mov     a,%1
3342         mov     c,%2
3343         rrc     a
3344         mov     %1,a
3345 %4:
3346 %3:
3347 } if notVolatile %1
3348
3349 // in_byte>>=1; if(in_bit) in_byte|=0x80;
3350 replace {
3351         mov     a,r%1
3352         clr     c
3353         rrc     a
3354         mov     r%1,a
3355         jnb     %2,%3
3356 %4:
3357         orl     ar%1,#0x80
3358 %3:
3359 } by {
3360         ;       Peephole 258.d  optimized bitbanging
3361         mov     a,r%1
3362         mov     c,%2
3363         rrc     a
3364         mov     r%1,a
3365 %4:
3366 %3:
3367 }
3368
3369 // out_bit=out_byte&0x80; out_byte<<=1;
3370 // helps f.e. writing data on a 3-wire (SPI) bus
3371 replace {
3372         mov     a,%1
3373         mov     c,acc.7
3374         mov     %2,c
3375         mov     a,%1
3376         add     a,%1
3377         mov     %1,a
3378 } by {
3379         ;       Peephole 258.e  optimized bitbanging
3380         mov     a,%1
3381         add     a,%1
3382         mov     %2,c
3383         mov     %1,a
3384 } if notVolatile %1
3385
3386 // out_bit=out_byte&0x01; out_byte>>=1;
3387 replace {
3388         mov     a,%1
3389         mov     c,acc.0
3390         mov     %2,c
3391         mov     a,%1
3392         clr     c
3393         rrc     a
3394         mov     %1,a
3395 } by {
3396         ;       Peephole 258.f  optimized bitbanging
3397         mov     a,%1
3398         clr     c
3399         rrc     a
3400         mov     %2,c
3401         mov     %1,a
3402 } if notVolatile %1
3403