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