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