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