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