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

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