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 } if 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 } if 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 } if 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 } if 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 } if 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 } if 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 } if 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 } if 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 } if 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 } if 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 } if 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 } if 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         clr     a
2219 } by {
2220         clr     a
2221         movx    @%1,a
2222         inc     %1
2223         ;       Peephole 226.a  removed unnecessary clr
2224 }
2225
2226 replace {
2227         clr     a
2228         movx    @%1,a
2229         inc     %1
2230         movx    @%1,a
2231         inc     %1
2232         clr     a
2233 } by {
2234         clr     a
2235         movx    @%1,a
2236         inc     %1
2237         movx    @%1,a
2238         inc     %1
2239         ;       Peephole 226.b  removed unnecessary clr
2240 }
2241
2242 replace {
2243         mov     dptr,#%1
2244         clr     a
2245         inc     dptr
2246         inc     dptr
2247         inc     dptr
2248         movx    @dptr,a
2249         lcall   __decdptr
2250         movx    @dptr,a
2251         lcall   __decdptr
2252         movx    @dptr,a
2253         lcall   __decdptr
2254         movx    @dptr,a
2255 } by {
2256         mov     dptr,#%1
2257         clr     a
2258         ;       Peephole 227.a  replaced inefficient 32 bit clear
2259         movx    @dptr,a
2260         inc     dptr
2261         movx    @dptr,a
2262         inc     dptr
2263         movx    @dptr,a
2264         inc     dptr
2265         movx    @dptr,a
2266         mov     dptr,#%1
2267 }
2268
2269 replace {
2270         mov     dptr,#%1
2271         clr     a
2272         inc     dptr
2273         inc     dptr
2274         inc     dptr
2275         movx    @dptr,a
2276         lcall   __decdptr
2277         movx    @dptr,a
2278         lcall   __decdptr
2279         movx    @dptr,a
2280         lcall   __decdptr
2281         mov     a,#%2
2282         movx    @dptr,a
2283 } by {
2284         mov     dptr,#%1
2285         ;       Peephole 227.b  replaced inefficient 32 constant
2286         mov     a,#%2
2287         movx    @dptr,a
2288         inc     dptr
2289         clr     a
2290         movx    @dptr,a
2291         inc     dptr
2292         movx    @dptr,a
2293         inc     dptr
2294         movx    @dptr,a
2295         mov     dptr,#%1
2296 }
2297
2298 replace {
2299         mov     dptr,#%1
2300         clr     a
2301         inc     dptr
2302         movx    @dptr,a
2303         lcall   __decdptr
2304         movx    @dptr,a
2305 } by {
2306         mov     dptr,#%1
2307         clr     a
2308         ;       Peephole 227.c  replaced inefficient 16 bit clear
2309         movx    @dptr,a
2310         inc     dptr
2311         movx    @dptr,a
2312         mov     dptr,#%1
2313 }
2314
2315 replace {
2316         mov     dptr,#%1
2317         clr     a
2318         inc     dptr
2319         movx    @dptr,a
2320         lcall   __decdptr
2321         mov     a,#%2
2322         movx    @dptr,a
2323 } by {
2324         mov     dptr,#%1
2325         ;       Peephole 227.d  replaced inefficient 16 bit constant
2326         mov     a,#%2
2327         movx    @dptr,a
2328         inc     dptr
2329         clr     a
2330         movx    @dptr,a
2331         mov     dptr,#%1
2332 }
2333
2334 // this last peephole often removes the last mov from 227.a - 227.d
2335 replace {
2336         mov     dptr,#%1
2337         mov     dptr,#%2
2338 } by {
2339         ;       Peephole 227.e  removed redundant mov to dptr
2340         mov     dptr,#%2
2341 }
2342
2343 replace {
2344         movx    a,@dptr
2345 } by {
2346         ;       Peephole 232    using movc to read xdata (--xram-movc)
2347         clr     a
2348         movc    a,@a+dptr
2349 } if xramMovcOption
2350
2351 replace {
2352         lcall   _gptrget
2353 } by {
2354         ;       Peephole 233    using _gptrgetc instead of _gptrget (--xram-movc)
2355         lcall   _gptrgetc
2356 } if xramMovcOption
2357
2358 replace {
2359         mov     r%1,a
2360         mov     dpl,r%1
2361 %2:
2362         ret
2363 } by {
2364         ;       Peephole 234.a  loading dpl directly from a(ccumulator), r%1 not set
2365         mov     dpl,a
2366 %2:
2367         ret
2368 }
2369
2370 replace {
2371         mov     r%1,a
2372         mov     dpl,r%2
2373         mov     dph,r%1
2374 %3:
2375         ret
2376 } by {
2377         ;       Peephole 234.b  loading dph directly from a(ccumulator), r%1 not set
2378         mov     dpl,r%2
2379         mov     dph,a
2380 %3:
2381         ret
2382 }
2383
2384 // 14 rules by Fiorenzo D. Ramaglia <fd.ramaglia@tin.it>
2385
2386 replace {
2387         add     a,ar%1
2388 } by {
2389         ;       Peephole 236.a  used r%1 instead of ar%1
2390         add     a,r%1
2391 }
2392
2393 replace {
2394         addc    a,ar%1
2395 } by {
2396         ;       Peephole 236.b  used r%1 instead of ar%1
2397         addc    a,r%1
2398 }
2399
2400 replace {
2401         anl     a,ar%1
2402 } by {
2403         ;       Peephole 236.c  used r%1 instead of ar%1
2404         anl     a,r%1
2405 }
2406
2407 replace {
2408         dec     ar%1
2409 } by {
2410         ;       Peephole 236.d  used r%1 instead of ar%1
2411         dec     r%1
2412 }
2413
2414 replace {
2415         djnz    ar%1,%2
2416 } by {
2417         ;       Peephole 236.e  used r%1 instead of ar%1
2418         djnz    r%1,%2
2419 }
2420
2421 replace {
2422         inc     ar%1
2423 } by {
2424         ;       Peephole 236.f  used r%1 instead of ar%1
2425         inc     r%1
2426 }
2427
2428 replace {
2429         mov     a,ar%1
2430 } by {
2431         ;       Peephole 236.g  used r%1 instead of ar%1
2432         mov     a,r%1
2433 }
2434
2435 replace {
2436         mov     ar%1,#%2
2437 } by {
2438         ;       Peephole 236.h  used r%1 instead of ar%1
2439         mov     r%1,#%2
2440 }
2441
2442 replace {
2443         mov     ar%1,a
2444 } by {
2445         ;       Peephole 236.i  used r%1 instead of ar%1
2446         mov     r%1,a
2447 }
2448
2449 replace {
2450         mov     ar%1,ar%2
2451 } by {
2452         ;       Peephole 236.j  used r%1 instead of ar%1
2453         mov     r%1,ar%2
2454 }
2455
2456 replace {
2457         orl     a,ar%1
2458 } by {
2459         ;       Peephole 236.k  used r%1 instead of ar%1
2460         orl     a,r%1
2461 }
2462
2463 replace {
2464         subb    a,ar%1
2465 } by {
2466         ;       Peephole 236.l  used r%1 instead of ar%1
2467         subb    a,r%1
2468 }
2469
2470 replace {
2471         xch     a,ar%1
2472 } by {
2473         ;       Peephole 236.m  used r%1 instead of ar%1
2474         xch     a,r%1
2475 }
2476
2477 replace {
2478         xrl     a,ar%1
2479 } by {
2480         ;       Peephole 236.n  used r%1 instead of ar%1
2481         xrl     a,r%1
2482 }
2483
2484 replace {
2485         sjmp    %1
2486 %2:
2487         mov     %3,%4
2488 %1:
2489         ret
2490 } by {
2491         ;       Peephole 237.a  removed sjmp to ret
2492         ret
2493 %2:
2494         mov     %3,%4
2495 %1:
2496         ret
2497 } if labelRefCountChange(%1 -1)
2498
2499 replace {
2500         sjmp    %1
2501 %2:
2502         mov     %3,%4
2503         mov     dpl,%5
2504         mov     dph,%6
2505 %1:
2506         ret
2507 } by {
2508         ;       Peephole 237.b  removed sjmp to ret
2509         ret
2510 %2:
2511         mov     %3,%4
2512         mov     dpl,%5
2513         mov     dph,%6
2514 %1:
2515         ret
2516 } if labelRefCountChange(%1 -1)
2517
2518 // applies to f.e. device/lib/log10f.c
2519 replace {
2520         mov     %1,%9
2521         mov     %2,%10
2522         mov     %3,%11
2523         mov     %4,%12
2524
2525         mov     %5,%13
2526         mov     %6,%14
2527         mov     %7,%15
2528         mov     %8,%16
2529
2530         mov     %9,%1
2531         mov     %10,%2
2532         mov     %11,%3
2533         mov     %12,%4
2534 } by {
2535         mov     %1,%9
2536         mov     %2,%10
2537         mov     %3,%11
2538         mov     %4,%12
2539
2540         mov     %5,%13
2541         mov     %6,%14
2542         mov     %7,%15
2543         mov     %8,%16
2544         ;       Peephole 238.a  removed 4 redundant moves
2545 } if operandsNotSame8 %1 %2 %3 %4 %5 %6 %7 %8
2546
2547 // applies to device/lib/log10f.c
2548 replace {
2549         mov     %1,%5
2550         mov     %2,%6
2551         mov     %3,%7
2552         mov     %4,%8
2553
2554         mov     %5,%1
2555         mov     %6,%2
2556         mov     %7,%3
2557 } by {
2558         mov     %1,%5
2559         mov     %2,%6
2560         mov     %3,%7
2561         mov     %4,%8
2562         ;       Peephole 238.b  removed 3 redundant moves
2563 } if operandsNotSame7 %1 %2 %3 %4 %5 %6 %7
2564
2565 // applies to f.e. device/lib/time.c
2566 replace {
2567         mov     %1,%5
2568         mov     %2,%6
2569
2570         mov     %3,%7
2571         mov     %4,%8
2572
2573         mov     %5,%1
2574         mov     %6,%2
2575 } by {
2576         mov     %1,%5
2577         mov     %2,%6
2578
2579         mov     %3,%7
2580         mov     %4,%8
2581         ;       Peephole 238.c  removed 2 redundant moves
2582 } if operandsNotSame4 %1 %2 %3 %4
2583
2584 // applies to f.e. support/regression/tests/bug-524209.c
2585 replace {
2586         mov     %1,%4
2587         mov     %2,%5
2588         mov     %3,%6
2589
2590         mov     %4,%1
2591         mov     %5,%2
2592         mov     %6,%3
2593 } by {
2594         mov     %1,%4
2595         mov     %2,%5
2596         mov     %3,%6
2597         ;       Peephole 238.d  removed 3 redundant moves
2598 } if operandsNotSame6 %1 %2 %3 %4 %5 %6
2599
2600 // applies to f.e. ser_ir.asm
2601 replace {
2602         mov     r%1,acc
2603 } by {
2604         ;       Peephole 239    used a instead of acc
2605         mov     r%1,a
2606 }
2607
2608 replace restart {
2609         mov     a,%1
2610         addc    a,#0x00
2611 } by {
2612         ;       Peephole 240    use clr instead of addc a,#0
2613         clr     a
2614         addc    a,%1
2615 }
2616
2617 // peepholes 241.a to 241.d and 241.e to 241.h need to be in order
2618 replace {
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         mov     a,#0x01
2624         sjmp    %1
2625 %0:
2626         clr     a
2627 %1:
2628 } by {
2629         ;       Peephole 241.a  optimized compare
2630         clr     a
2631         cjne    r%2,#%3,%0
2632         cjne    r%4,#%5,%0
2633         cjne    r%6,#%7,%0
2634         cjne    r%8,#%9,%0
2635         inc     a
2636 %0:
2637 %1:
2638 } if labelRefCountChange(%1 -1)
2639
2640 // applies to generic pointer compare
2641 replace {
2642         cjne    r%2,#%3,%0
2643         cjne    r%4,#%5,%0
2644         cjne    r%6,#%7,%0
2645         mov     a,#0x01
2646         sjmp    %1
2647 %0:
2648         clr     a
2649 %1:
2650 } by {
2651         ;       Peephole 241.b  optimized compare
2652         clr     a
2653         cjne    r%2,#%3,%0
2654         cjne    r%4,#%5,%0
2655         cjne    r%6,#%7,%0
2656         inc     a
2657 %0:
2658 %1:
2659 } if labelRefCountChange(%1 -1)
2660
2661 // applies to f.e. time.c
2662 replace {
2663         cjne    r%2,#%3,%0
2664         cjne    r%4,#%5,%0
2665         mov     a,#0x01
2666         sjmp    %1
2667 %0:
2668         clr     a
2669 %1:
2670 } by {
2671         ;       Peephole 241.c  optimized compare
2672         clr     a
2673         cjne    r%2,#%3,%0
2674         cjne    r%4,#%5,%0
2675         inc     a
2676 %0:
2677 %1:
2678 } if labelRefCountChange(%1 -1)
2679
2680 // applies to f.e. malloc.c
2681 replace {
2682         cjne    r%2,#%3,%0
2683         mov     a,#0x01
2684         sjmp    %1
2685 %0:
2686         clr     a
2687 %1:
2688 } by {
2689         ;       Peephole 241.d  optimized compare
2690         clr     a
2691         cjne    r%2,#%3,%0
2692         inc     a
2693 %0:
2694 %1:
2695 } if labelRefCountChange(%1 -1)
2696
2697 // applies to f.e. j = (k!=0x1000);
2698 // with volatile idata long k;
2699 replace {
2700         cjne    @r%0,#%3,%1
2701         inc     r%0
2702         cjne    @r%0,#%4,%1
2703         inc     r%0
2704         cjne    @r%0,#%5,%1
2705         inc     r%0
2706         cjne    @r%0,#%6,%1
2707         mov     a,#0x01
2708         sjmp    %2
2709 %1:
2710         clr     a
2711 %2:
2712 } by {
2713         ;       Peephole 241.e  optimized compare
2714         clr     a
2715         cjne    @r%0,#%3,%1
2716         inc     r%0
2717         cjne    @r%0,#%4,%1
2718         inc     r%0
2719         cjne    @r%0,#%5,%1
2720         inc     r%0
2721         cjne    @r%0,#%6,%1
2722         inc     a
2723 %1:
2724 %2:
2725 } if labelRefCountChange(%2 -1)
2726
2727 // applies to f.e. j = (p!=NULL);
2728 // with volatile idata char *p;
2729 replace {
2730         cjne    @r%0,#%3,%1
2731         inc     r%0
2732         cjne    @r%0,#%4,%1
2733         inc     r%0
2734         cjne    @r%0,#%5,%1
2735         mov     a,#0x01
2736         sjmp    %2
2737 %1:
2738         clr     a
2739 %2:
2740 } by {
2741         ;       Peephole 241.f  optimized compare
2742         clr     a
2743         cjne    @r%0,#%3,%1
2744         inc     r%0
2745         cjne    @r%0,#%4,%1
2746         inc     r%0
2747         cjne    @r%0,#%5,%1
2748         inc     a
2749 %1:
2750 %2:
2751 } if labelRefCountChange(%2 -1)
2752
2753 // applies to f.e. j = (k!=0x1000);
2754 // with volatile idata int k;
2755 replace {
2756         cjne    @r%0,#%3,%1
2757         inc     r%0
2758         cjne    @r%0,#%4,%1
2759         mov     a,#0x01
2760         sjmp    %2
2761 %1:
2762         clr     a
2763 %2:
2764 } by {
2765         ;       Peephole 241.g  optimized compare
2766         clr     a
2767         cjne    @r%0,#%3,%1
2768         inc     r%0
2769         cjne    @r%0,#%4,%1
2770         inc     a
2771 %1:
2772 %2:
2773 } if labelRefCountChange(%2 -1)
2774
2775 // applies to f.e. vprintf.asm (--stack-auto)
2776 replace {
2777         cjne    @r%0,#%3,%1
2778         mov     a,#0x01
2779         sjmp    %2
2780 %1:
2781         clr     a
2782 %2:
2783 } by {
2784         ;       Peephole 241.h  optimized compare
2785         clr     a
2786         cjne    @r%0,#%3,%1
2787         inc     a
2788 %1:
2789 %2:
2790 } if labelRefCountChange(%2 -1)
2791
2792 // applies to f.e. scott-bool1.c
2793 replace {
2794         jnz     %1
2795         mov     %2,%3
2796 %1:
2797         jz      %4
2798 } by {
2799         jnz     %1
2800         mov     %2,%3
2801         ;       Peephole 242.a  avoided branch jnz to jz
2802         jz      %4
2803 %1:
2804 } if labelRefCount %1 1
2805
2806 // applies to f.e. scott-bool1.c
2807 replace {
2808         jnz     %1
2809         mov     %2,%3
2810         orl     a,%5
2811 %1:
2812         jz      %4
2813 } by {
2814         jnz     %1
2815         mov     %2,%3
2816         orl     a,%5
2817         ;       Peephole 242.b  avoided branch jnz to jz
2818         jz      %4
2819 %1:
2820 } if labelRefCount %1 1
2821
2822 // applies to f.e. logic.c
2823 replace {
2824         jnz     %1
2825         mov     %2,%3
2826         orl     a,%5
2827         orl     a,%6
2828         orl     a,%7
2829 %1:
2830         jz      %4
2831 } by {
2832         jnz     %1
2833         mov     %2,%3
2834         orl     a,%5
2835         orl     a,%6
2836         orl     a,%7
2837         ;       Peephole 242.c  avoided branch jnz to jz
2838         jz      %4
2839 %1:
2840 } if labelRefCount %1 1
2841
2842 // applies to f.e. vprintf.c
2843 // this is a rare case, usually the "tail increment" is noticed earlier
2844 replace {
2845         cjne    %1,%2,%3
2846         inc     %4
2847 %3:
2848         sjmp    %5
2849 } by {
2850         ;       Peephole 243    avoided branch to sjmp
2851         cjne    %1,%2,%5
2852         inc     %4
2853 %3:
2854         sjmp    %5
2855 } if labelInRange(), labelRefCountChange(%3 -1), labelRefCountChange(%5 1)
2856
2857 // applies to f.e. simplefloat.c (saving 1 cycle)
2858 replace {
2859         mov     r%1,dpl
2860         mov     a,r%1
2861 } by {
2862         ;       Peephole 244.a  moving first to a instead of r%1
2863         mov     a,dpl
2864         mov     r%1,a
2865 }
2866
2867 // applies to f.e. _itoa.c (saving 1 cycle)
2868 replace {
2869         mov     r%1,dph
2870         mov     a,r%1
2871 } by {
2872         ;       Peephole 244.b  moving first to a instead of r%1
2873         mov     a,dph
2874         mov     r%1,a
2875 }
2876
2877
2878 // applies to f.e. bug-460010.c (saving 1 cycle)
2879 replace {
2880         mov     r%1,a
2881         mov     dpl,r%1
2882 } by {
2883         mov     r%1,a
2884         ;       Peephole 244.c  loading dpl from a instead of r%1
2885         mov     dpl,a
2886 }
2887
2888 replace {
2889         mov     r%1,a
2890         mov     dph,r%1
2891 } by {
2892         mov     r%1,a
2893         ;       Peephole 244.d  loading dph from a instead of r%1
2894         mov     dph,a
2895 }
2896
2897 // this one is safe but disables 245.a 245.b
2898 // please remove 245 if 245.a 245.b are found to be safe
2899 // applies to f.e. scott-compare.c
2900 replace {
2901         clr     a
2902         rlc     a
2903         mov     r%1,a
2904         cjne    a,#0x01,%2
2905 %2:
2906         clr     a
2907         rlc     a
2908         mov     r%1,a
2909 } by {
2910         ;       Peephole 245    optimized complement (r%1 and acc set needed?)
2911         cpl     c
2912         clr     a
2913         rlc     a
2914         mov     r%1,a
2915 } if labelRefCount(%2 1), labelRefCountChange(%2 -1)
2916
2917 // this one will not be triggered if 245 is present
2918 // please remove 245 if 245.a 245.b are found to be safe
2919 // applies to f.e. vprintf.c
2920 replace {
2921         clr     a
2922         rlc     a
2923         mov     r%1,a
2924         cjne    a,#0x01,%2
2925 %2:
2926         clr     a
2927         rlc     a
2928         mov     r%1,a
2929         jz      %3
2930 } by {
2931         ;       Peephole 245.a  optimized conditional jump (r%1 and acc not set!)
2932         jc      %3
2933 } if labelRefCount(%2 1), labelRefCountChange(%2 -1)
2934
2935 // this one will not be triggered if 245 is present
2936 // please remove 245 if 245.a 245.b are found to be safe
2937 // applies to f.e. scott-compare.c
2938 replace {
2939         clr     a
2940         rlc     a
2941         mov     r%1,a
2942         cjne    a,#0x01,%2
2943 %2:
2944         clr     a
2945         rlc     a
2946         mov     r%1,a
2947         jnz     %3
2948 } by {
2949         ;       Peephole 245.b  optimized conditional jump (r%1 and acc not set!)
2950         jnc     %3
2951 } if labelRefCount(%2 1), labelRefCountChange(%2 -1)
2952
2953
2954 // rules 246.x apply to f.e. bitfields.c
2955 replace {
2956         mov     dptr,#%1
2957         movx    a,@dptr
2958         anl     a,#%2
2959         movx    @dptr,a
2960         mov     dptr,#%1
2961         movx    a,@dptr
2962         anl     a,#%3
2963         movx    @dptr,a
2964 } by {
2965         mov     dptr,#%1
2966         movx    a,@dptr
2967         ;       Peephole 246.a  combined clr/clr
2968         anl     a,#%2&%3
2969         movx    @dptr,a
2970 } if notVolatile %1
2971
2972 replace {
2973         mov     dptr,#%1
2974         movx    a,@dptr
2975         orl     a,#%2
2976         movx    @dptr,a
2977         mov     dptr,#%1
2978         movx    a,@dptr
2979         orl     a,#%3
2980         movx    @dptr,a
2981 } by {
2982         mov     dptr,#%1
2983         movx    a,@dptr
2984         ;       Peephole 246.b  combined set/set
2985         orl     a,#%2|%3
2986         movx    @dptr,a
2987 } if notVolatile %1
2988
2989 replace {
2990         mov     dptr,#%1
2991         movx    a,@dptr
2992         orl     a,#%2
2993         movx    @dptr,a
2994         mov     dptr,#%1
2995         movx    a,@dptr
2996         anl     a,#%3
2997         movx    @dptr,a
2998 } by {
2999         mov     dptr,#%1
3000         movx    a,@dptr
3001         orl     a,#%2
3002         ;       Peephole 246.c  combined set/clr
3003         anl     a,#%3
3004         movx    @dptr,a
3005 } if notVolatile %1
3006
3007 replace {
3008         mov     dptr,#%1
3009         movx    a,@dptr
3010         anl     a,#%2
3011         movx    @dptr,a
3012         mov     dptr,#%1
3013         movx    a,@dptr
3014         orl     a,#%3
3015         movx    @dptr,a
3016 } by {
3017         mov     dptr,#%1
3018         movx    a,@dptr
3019         anl     a,#%2
3020         ;       Peephole 246.d  combined clr/set
3021         orl     a,#%3
3022         movx    @dptr,a
3023 } if notVolatile %1
3024
3025 replace {
3026         mov     dptr,#%1
3027         movx    a,@dptr
3028         orl     a,#%2
3029         anl     a,#%3
3030         movx    @dptr,a
3031         mov     dptr,#%1
3032         movx    a,@dptr
3033         anl     a,#%4
3034         movx    @dptr,a
3035 } by {
3036         mov     dptr,#%1
3037         movx    a,@dptr
3038         orl     a,#%2
3039         ;       Peephole 246.e  combined set/clr/clr
3040         anl     a,#%3&%4
3041         movx    @dptr,a
3042 } if notVolatile %1
3043
3044 replace {
3045         mov     dptr,#%1
3046         movx    a,@dptr
3047         orl     a,#%2
3048         anl     a,#%3
3049         movx    @dptr,a
3050         mov     dptr,#%1
3051         movx    a,@dptr
3052         orl     a,#%4
3053         movx    @dptr,a
3054 } by {
3055         mov     dptr,#%1
3056         movx    a,@dptr
3057         orl     a,#%2
3058         anl     a,#%3
3059         ;       Peephole 246.f  combined set/clr/set
3060         orl     a,#%4
3061         movx    @dptr,a
3062 } if notVolatile %1
3063
3064 replace {
3065         mov     dptr,#%1
3066         movx    a,@dptr
3067         anl     a,#%2
3068         orl     a,#%3
3069         movx    @dptr,a
3070         mov     dptr,#%1
3071         movx    a,@dptr
3072         anl     a,#%4
3073         movx    @dptr,a
3074 } by {
3075         mov     dptr,#%1
3076         movx    a,@dptr
3077         anl     a,#%2
3078         orl     a,#%3
3079         ;       Peephole 246.g  combined clr/set/clr
3080         anl     a,#%4
3081         movx    @dptr,a
3082 } if notVolatile %1
3083
3084 replace {
3085         mov     dptr,#%1
3086         movx    a,@dptr
3087         anl     a,#%2
3088         orl     a,#%3
3089         movx    @dptr,a
3090         mov     dptr,#%1
3091         movx    a,@dptr
3092         orl     a,#%4
3093         movx    @dptr,a
3094 } by {
3095         mov     dptr,#%1
3096         movx    a,@dptr
3097         anl     a,#%2
3098         ;       Peephole 246.h  combined clr/set/set
3099         orl     a,#%3|%4
3100         movx    @dptr,a
3101 } if notVolatile %1
3102
3103
3104
3105
3106 // rules 247.x apply to f.e. bitfields.c
3107 replace {
3108         mov     r%5,#%1
3109         mov     a,@r%5
3110         anl     a,#%2
3111         mov     @r%5,a
3112         mov     r%5,#%1
3113         mov     a,@r%5
3114         anl     a,#%3
3115         mov     @r%5,a
3116 } by {
3117         mov     r%5,#%1
3118         mov     a,@r%5
3119         ;       Peephole 247.a  combined clr/clr
3120         anl     a,#%2&%3
3121         mov     @r%5,a
3122 } if notVolatile %1
3123
3124 replace {
3125         mov     r%5,#%1
3126         mov     a,@r%5
3127         orl     a,#%2
3128         mov     @r%5,a
3129         mov     r%5,#%1
3130         mov     a,@r%5
3131         orl     a,#%3
3132         mov     @r%5,a
3133 } by {
3134         mov     r%5,#%1
3135         mov     a,@r%5
3136         ;       Peephole 247.b  combined set/set
3137         orl     a,#%2|%3
3138         mov     @r%5,a
3139 } if notVolatile %1
3140
3141 replace {
3142         mov     r%5,#%1
3143         mov     a,@r%5
3144         orl     a,#%2
3145         mov     @r%5,a
3146         mov     r%5,#%1
3147         mov     a,@r%5
3148         anl     a,#%3
3149         mov     @r%5,a
3150 } by {
3151         mov     r%5,#%1
3152         mov     a,@r%5
3153         orl     a,#%2
3154         ;       Peephole 247.c  combined set/clr
3155         anl     a,#%3
3156         mov     @r%5,a
3157 } if notVolatile %1
3158
3159 replace {
3160         mov     r%5,#%1
3161         mov     a,@r%5
3162         anl     a,#%2
3163         mov     @r%5,a
3164         mov     r%5,#%1
3165         mov     a,@r%5
3166         orl     a,#%3
3167         mov     @r%5,a
3168 } by {
3169         mov     r%5,#%1
3170         mov     a,@r%5
3171         anl     a,#%2
3172         ;       Peephole 247.d  combined clr/set
3173         orl     a,#%3
3174         mov     @r%5,a
3175 } if notVolatile %1
3176
3177 replace {
3178         mov     r%5,#%1
3179         mov     a,@r%5
3180         orl     a,#%2
3181         anl     a,#%3
3182         mov     @r%5,a
3183         mov     r%5,#%1
3184         mov     a,@r%5
3185         anl     a,#%4
3186         mov     @r%5,a
3187 } by {
3188         mov     r%5,#%1
3189         mov     a,@r%5
3190         orl     a,#%2
3191         ;       Peephole 247.e  combined set/clr/clr
3192         anl     a,#%3&%4
3193         mov     @r%5,a
3194 } if notVolatile %1
3195
3196 replace {
3197         mov     r%5,#%1
3198         mov     a,@r%5
3199         orl     a,#%2
3200         anl     a,#%3
3201         mov     @r%5,a
3202         mov     r%5,#%1
3203         mov     a,@r%5
3204         orl     a,#%4
3205         mov     @r%5,a
3206 } by {
3207         mov     r%5,#%1
3208         mov     a,@r%5
3209         orl     a,#%2
3210         anl     a,#%3
3211         ;       Peephole 247.f  combined set/clr/set
3212         orl     a,#%4
3213         mov     @r%5,a
3214 } if notVolatile %1
3215
3216 replace {
3217         mov     r%5,#%1
3218         mov     a,@r%5
3219         anl     a,#%2
3220         orl     a,#%3
3221         mov     @r%5,a
3222         mov     r%5,#%1
3223         mov     a,@r%5
3224         anl     a,#%4
3225         mov     @r%5,a
3226 } by {
3227         mov     r%5,#%1
3228         mov     a,@r%5
3229         anl     a,#%2
3230         orl     a,#%3
3231         ;       Peephole 247.g  combined clr/set/clr
3232         anl     a,#%4
3233         mov     @r%5,a
3234 } if notVolatile %1
3235
3236 replace {
3237         mov     r%5,#%1
3238         mov     a,@r%5
3239         anl     a,#%2
3240         orl     a,#%3
3241         mov     @r%5,a
3242         mov     r%5,#%1
3243         mov     a,@r%4
3244         orl     a,#%4
3245         mov     @r%5,a
3246 } by {
3247         mov     r%5,#%1
3248         mov     a,@r%5
3249         anl     a,#%2
3250         ;       Peephole 247.h  combined clr/set/set
3251         orl     a,#%3|%4
3252         mov     @r%5,a
3253 } if notVolatile %1
3254
3255
3256 // Peepholes 248.x have to be compatible with the keyword volatile.
3257 // They optimize typical accesses to memory mapped I/O devices:
3258 // volatile xdata char t; t|=0x01;
3259 replace {
3260         mov     dptr,%1
3261         movx    a,@dptr
3262         mov     r%2,a
3263         mov     dptr,%1
3264         mov     a,%3
3265         orl     a,r%2
3266         movx    @dptr,a
3267 } by {
3268         mov     dptr,%1
3269         movx    a,@dptr
3270         mov     r%2,a
3271         ;       Peephole 248.a  optimized or to xdata
3272         orl     a,%3
3273         movx    @dptr,a
3274 }
3275
3276 // volatile xdata char t; t&=0x01;
3277 replace {
3278         mov     dptr,%1
3279         movx    a,@dptr
3280         mov     r%2,a
3281         mov     dptr,%1
3282         mov     a,%3
3283         anl     a,r%2
3284         movx    @dptr,a
3285 } by {
3286         mov     dptr,%1
3287         movx    a,@dptr
3288         mov     r%2,a
3289         ;       Peephole 248.b  optimized and to xdata
3290         anl     a,%3
3291         movx    @dptr,a
3292 }
3293
3294 // volatile xdata char t; t^=0x01;
3295 replace {
3296         mov     dptr,%1
3297         movx    a,@dptr
3298         mov     r%2,a
3299         mov     dptr,%1
3300         mov     a,%3
3301         xrl     a,r%2
3302         movx    @dptr,a
3303 } by {
3304         mov     dptr,%1
3305         movx    a,@dptr
3306         mov     r%2,a
3307         ;       Peephole 248.c  optimized xor to xdata
3308         xrl     a,%3
3309         movx    @dptr,a
3310 }
3311
3312 // volatile xdata char t; t|=0x01; t&=~0x01; t|=0x01;
3313 replace {
3314         mov     dptr,%1
3315         movx    a,@dptr
3316         mov     r%2,a
3317         orl     a,%3
3318         movx    @dptr,a
3319
3320         mov     dptr,%1
3321         movx    a,@dptr
3322         mov     r%2,a
3323         anl     a,%4
3324         movx    @dptr,a
3325
3326         mov     dptr,%1
3327         movx    a,@dptr
3328         mov     r%2,a
3329         orl     a,%5
3330         movx    @dptr,a
3331 } by {
3332         mov     dptr,%1
3333         movx    a,@dptr
3334         ;       Peephole 248.d  optimized or/and/or to volatile xdata
3335         orl     a,%3
3336         movx    @dptr,a
3337         movx    a,@dptr
3338         anl     a,%4
3339         movx    @dptr,a
3340         movx    a,@dptr
3341         mov     r%2,a
3342         orl     a,%5
3343         movx    @dptr,a
3344 }
3345
3346 // volatile xdata char t; t&=~0x01; t|=0x01; t&=~0x01;
3347 replace {
3348         mov     dptr,%1
3349         movx    a,@dptr
3350         mov     r%2,a
3351         anl     a,%3
3352         movx    @dptr,a
3353
3354         mov     dptr,%1
3355         movx    a,@dptr
3356         mov     r%2,a
3357         orl     a,%4
3358         movx    @dptr,a
3359
3360         mov     dptr,%1
3361         movx    a,@dptr
3362         mov     r%2,a
3363         anl     a,%5
3364         movx    @dptr,a
3365 } by {
3366         mov     dptr,%1
3367         movx    a,@dptr
3368         ;       Peephole 248.e  optimized and/or/and to volatile xdata
3369         anl     a,%3
3370         movx    @dptr,a
3371         movx    a,@dptr
3372         orl     a,%4
3373         movx    @dptr,a
3374         movx    a,@dptr
3375         mov     r%2,a
3376         anl     a,%5
3377         movx    @dptr,a
3378 }
3379
3380 // volatile xdata char t; t|=0x01; t&=~0x01;
3381 replace {
3382         mov     dptr,%1
3383         movx    a,@dptr
3384         mov     r%2,a
3385         orl     a,%3
3386         movx    @dptr,a
3387
3388         mov     dptr,%1
3389         movx    a,@dptr
3390         mov     r%2,a
3391         anl     a,%4
3392         movx    @dptr,a
3393 } by {
3394         mov     dptr,%1
3395         movx    a,@dptr
3396         ;       Peephole 248.f  optimized or/and to volatile xdata
3397         orl     a,%3
3398         movx    @dptr,a
3399         movx    a,@dptr
3400         mov     r%2,a
3401         anl     a,%4
3402         movx    @dptr,a
3403 }
3404
3405 // volatile xdata char t; t&=~0x01; t|=0x01;
3406 replace {
3407         mov     dptr,%1
3408         movx    a,@dptr
3409         mov     r%2,a
3410         anl     a,%3
3411         movx    @dptr,a
3412
3413         mov     dptr,%1
3414         movx    a,@dptr
3415         mov     r%2,a
3416         orl     a,%4
3417         movx    @dptr,a
3418 } by {
3419         mov     dptr,%1
3420         movx    a,@dptr
3421         ;       Peephole 248.g  optimized and/or to volatile xdata
3422         anl     a,%3
3423         movx    @dptr,a
3424         movx    a,@dptr
3425         mov     r%2,a
3426         orl     a,%4
3427         movx    @dptr,a
3428 }
3429
3430 // volatile xdata char t; t^=0x01; t^=0x01;
3431 replace {
3432         mov     dptr,%1
3433         movx    a,@dptr
3434         mov     r%2,a
3435         xrl     a,%3
3436         movx    @dptr,a
3437
3438         mov     dptr,%1
3439         movx    a,@dptr
3440         mov     r%2,a
3441         xrl     a,%4
3442         movx    @dptr,a
3443 } by {
3444         mov     dptr,%1
3445         movx    a,@dptr
3446         ;       Peephole 248.h  optimized xor/xor to volatile xdata
3447         xrl     a,%3
3448         movx    @dptr,a
3449         movx    a,@dptr
3450         mov     r%2,a
3451         xrl     a,%4
3452         movx    @dptr,a
3453 }
3454
3455 // Peeepholes 248.i to 248.m are like 248.d to 248.h except they apply to bitfields:
3456 // xdata struct { unsigned b0:1; unsigned b1:1; unsigned b2:1; } xport;
3457 // xport.b0=1; xport.b0=0; xport.b0=1;
3458 replace {
3459         mov     dptr,%1
3460         movx    a,@dptr
3461         orl     a,%3
3462         movx    @dptr,a
3463
3464         mov     dptr,%1
3465         movx    a,@dptr
3466         anl     a,%4
3467         movx    @dptr,a
3468
3469         mov     dptr,%1
3470         movx    a,@dptr
3471         orl     a,%5
3472         movx    @dptr,a
3473 } by {
3474         mov     dptr,%1
3475         movx    a,@dptr
3476         orl     a,%3
3477         movx    @dptr,a
3478         ;       Peephole 248.i  optimized or/and/or to xdata bitfield
3479         movx    a,@dptr
3480         anl     a,%4
3481         movx    @dptr,a
3482         movx    a,@dptr
3483         orl     a,%5
3484         movx    @dptr,a
3485 }
3486
3487 replace {
3488         mov     dptr,%1
3489         movx    a,@dptr
3490         anl     a,%3
3491         movx    @dptr,a
3492
3493         mov     dptr,%1
3494         movx    a,@dptr
3495         orl     a,%4
3496         movx    @dptr,a
3497
3498         mov     dptr,%1
3499         movx    a,@dptr
3500         anl     a,%5
3501         movx    @dptr,a
3502 } by {
3503         mov     dptr,%1
3504         movx    a,@dptr
3505         anl     a,%3
3506         movx    @dptr,a
3507         ;       Peephole 248.j  optimized and/or/and to xdata bitfield
3508         movx    a,@dptr
3509         orl     a,%4
3510         movx    @dptr,a
3511         movx    a,@dptr
3512         anl     a,%5
3513         movx    @dptr,a
3514 }
3515
3516 replace {
3517         mov     dptr,%1
3518         movx    a,@dptr
3519         orl     a,%3
3520         movx    @dptr,a
3521
3522         mov     dptr,%1
3523         movx    a,@dptr
3524         anl     a,%4
3525         movx    @dptr,a
3526 } by {
3527         mov     dptr,%1
3528         movx    a,@dptr
3529         orl     a,%3
3530         movx    @dptr,a
3531         ;       Peephole 248.k  optimized or/and to xdata bitfield
3532         movx    a,@dptr
3533         anl     a,%4
3534         movx    @dptr,a
3535 }
3536
3537 replace {
3538         mov     dptr,%1
3539         movx    a,@dptr
3540         anl     a,%3
3541         movx    @dptr,a
3542
3543         mov     dptr,%1
3544         movx    a,@dptr
3545         orl     a,%4
3546         movx    @dptr,a
3547 } by {
3548         mov     dptr,%1
3549         movx    a,@dptr
3550         anl     a,%3
3551         movx    @dptr,a
3552         ;       Peephole 248.l  optimized and/or to xdata bitfield
3553         movx    a,@dptr
3554         orl     a,%4
3555         movx    @dptr,a
3556 }
3557
3558 replace {
3559         mov     dptr,%1
3560         movx    a,@dptr
3561         xrl     a,%3
3562         movx    @dptr,a
3563
3564         mov     dptr,%1
3565         movx    a,@dptr
3566         xrl     a,%4
3567         movx    @dptr,a
3568 } by {
3569         mov     dptr,%1
3570         movx    a,@dptr
3571         xrl     a,%3
3572         movx    @dptr,a
3573         ;       Peephole 248.m  optimized xor/xor to xdata bitfield
3574         movx    a,@dptr
3575         xrl     a,%4
3576         movx    @dptr,a
3577 }
3578
3579
3580 replace {
3581         jnz     %1
3582 %1:
3583 } by {
3584         ;       Peephole 249.a   jump optimization
3585 } if labelRefCount(%1 1), labelRefCountChange(%1 -1)
3586
3587 replace {
3588         jz      %1
3589 %1:
3590 } by {
3591         ;       Peephole 249.b   jump optimization
3592 } if labelRefCount(%1 1), labelRefCountChange(%1 -1)
3593
3594
3595 // This allows non-interrupt and interrupt code to safely compete
3596 // for a resource without the non-interrupt code having to disable
3597 // interrupts:
3598 // volatile bit resource_is_free;
3599 // if( resource_is_free ) {
3600 //     resource_is_free=0; do_something; resource_is_free=1;
3601 // }
3602 replace {
3603         jnb     %1,%2
3604 %3:
3605         clr     %1
3606 } by {
3607         ;       Peephole 250.a  using atomic test and clear
3608         jbc     %1,%3
3609         sjmp    %2
3610 %3:
3611 } if labelRefCount(%3 0), labelRefCountChange(%3 1)
3612
3613 replace {
3614         jb      %1,%2
3615         ljmp    %3
3616 %2:
3617         clr     %1
3618 } by {
3619         ;       Peephole 250.b  using atomic test and clear
3620         jbc     %1,%2
3621         ljmp    %3
3622 %2:
3623 } if labelRefCount %2 1
3624
3625
3626 // not before peephole 250.b
3627 replace {
3628         ljmp    %5
3629 } by {
3630         ;       Peephole 251.a  replaced ljmp to ret with ret
3631         ret
3632 } if labelIsReturnOnly(), labelRefCountChange(%5 -1)
3633
3634 // not before peephole 250.b
3635 replace {
3636         sjmp    %5
3637 } by {
3638         ;       Peephole 251.b  replaced sjmp to ret with ret
3639         ret
3640 } if labelIsReturnOnly(), labelRefCountChange(%5 -1)
3641
3642 // applies to shifts.c and when accessing arrays with an unsigned integer index
3643 // saving 1 byte, 2 cycles
3644 replace {
3645         mov     r%1,%2
3646         mov     a,(%2 + 1)
3647         xch     a,r%1
3648         add     a,acc
3649         xch     a,r%1
3650         rlc     a
3651         mov     r%3,a
3652 } by {
3653         ;       Peephole 252    optimized left shift
3654         mov     a,%2
3655         add     a,acc
3656         mov     r%1,a
3657         mov     a,(%2 + 1)
3658         rlc     a
3659         mov     r%3,a
3660 }
3661
3662 // applies to: void test( char c ) { if( c ) func1(); else func2(); }
3663 replace {
3664         lcall   %1
3665         ret
3666 } by {
3667         ;       Peephole 253.a  replaced lcall/ret with ljmp
3668         ljmp    %1
3669 }
3670
3671 // applies to: void test( char c ) { if( c ) func1(); else func2(); }
3672 replace {
3673         lcall   %1
3674 %2:
3675         ret
3676 } by {
3677         ;       Peephole 253.b  replaced lcall/ret with ljmp
3678         ljmp    %1
3679         ;
3680 } if labelRefCount %2 0
3681
3682 // applies to f.e. scott-bool1.c
3683 replace {
3684         lcall   %1
3685 %2:
3686         ret
3687 } by {
3688         ;       Peephole 253.c  replaced lcall with ljmp
3689         ljmp    %1
3690 %2:
3691         ret
3692 }
3693
3694
3695 // applies to f.e. funptrs.c
3696 // saves one byte if %1 is a register or @register
3697 replace {
3698         mov     a,%1
3699         add     a,acc
3700 } by {
3701         mov     a,%1
3702         ;       Peephole 254    optimized left shift
3703         add     a,%1
3704 } if notVolatile %1
3705
3706 // applies to f.e. switch.c
3707 replace {
3708         clr     c
3709         mov     a,#%1
3710         subb    a,%2
3711         jc      %3
3712 %4:
3713         mov     a,%2
3714         add     a,%2
3715         add     a,%2
3716         mov     dptr,%5
3717         jmp     @a+dptr
3718 } by {
3719         ;       Peephole 255    optimized jump table index calculation
3720         mov     a,%2
3721         cjne    a,#(%1+0x01),.+1
3722         jnc     %3
3723 %4:
3724         add     a,%2
3725         add     a,%2
3726         mov     dptr,%5
3727         jmp     @a+dptr
3728 }
3729
3730 // applies to f.e. jump tables and scott-bool1.c.
3731 // similar peepholes can be constructed for other instructions
3732 // after which a flag or a register is known (like: djnz, cjne, jnc)
3733 replace {
3734         jc      %1
3735 %2:
3736         clr     c
3737 } by {
3738         jc      %1
3739 %2:
3740         ;       Peephole 256.a  removed redundant clr c
3741 } if labelRefCount %2 0
3742
3743 // applies to f.e. logf.c
3744 replace {
3745         jnz     %1
3746 %2:
3747         clr     a
3748 } by {
3749         jnz     %1
3750 %2:
3751         ;       Peephole 256.b  removed redundant clr a
3752 } if labelRefCount %2 0
3753
3754 // applies to f.e. bug-905492.c
3755 replace {
3756         jnz     %1
3757 %2:
3758         mov     %3,#0x00
3759 } by {
3760         jnz     %1
3761 %2:
3762         ;       Peephole 256.c  loading %3 with zero from a
3763         mov     %3,a
3764 } if labelRefCount %2 0
3765
3766 // applies to f.e. malloc.c
3767 replace {
3768         jnz     %1
3769 %2:
3770         mov     %4,%5
3771         mov     %3,#0x00
3772 } by {
3773         jnz     %1
3774 %2:
3775         mov     %4,%5
3776         ;       Peephole 256.d  loading %3 with zero from a
3777         mov     %3,a
3778 } if labelRefCount(%2 0),operandsNotRelated('a' %4)
3779
3780 replace {
3781         jnz     %1
3782 %2:
3783         mov     %4,%5
3784         mov     %6,%7
3785         mov     %3,#0x00
3786 } by {
3787         jnz     %1
3788 %2:
3789         mov     %4,%5
3790         mov     %6,%7
3791         ;       Peephole 256.e  loading %3 with zero from a
3792         mov     %3,a
3793 } if labelRefCount(%2 0),operandsNotRelated('a' %4 %6)
3794
3795 replace {
3796         jnz     %1
3797 %2:
3798         mov     %4,%5
3799         mov     %6,%7
3800         mov     %8,%9
3801         mov     %3,#0x00
3802 } by {
3803         jnz     %1
3804 %2:
3805         mov     %4,%5
3806         mov     %6,%7
3807         mov     %8,%9
3808         ;       Peephole 256.f  loading %2 with zero from a
3809         mov     %3,a
3810 } if labelRefCount(%2 0),operandsNotRelated('a' %4 %6 %8)
3811
3812
3813 // unsigned char i=8; do{ } while(--i != 0);
3814 // this currently only applies if i is kept in a register
3815 replace {
3816         dec     %1
3817         cjne    %1,#0x00,%2
3818 } by {
3819         ;       Peephole 257    optimized decrement with compare
3820         djnz    %1,%2
3821 } if notVolatile %1
3822
3823
3824 // in_byte<<=1; if(in_bit) in_byte|=1;
3825 // helps f.e. reading data on a 3-wire (SPI) bus
3826 replace {
3827         mov     a,%1
3828         add     a,%1
3829         mov     %1,a
3830         jnb     %2,%3
3831 %4:
3832         orl     %1,#0x01
3833 %3:
3834 } by {
3835         mov     a,%1
3836         ;       Peephole 258.a  optimized bitbanging
3837         mov     c,%2
3838         addc    a,%1
3839         mov     %1,a
3840 %4:
3841 %3:
3842 } if notVolatile(%1), labelRefCountChange(%3 -1)
3843
3844 // in_byte<<=1; if(in_bit) in_byte|=1;
3845 replace {
3846         mov     a,r%1
3847         add     a,r%1
3848         mov     r%1,a
3849         jnb     %2,%3
3850 %4:
3851         orl     ar%1,#0x01
3852 %3:
3853 } by {
3854         mov     a,r%1
3855         ;       Peephole 258.b  optimized bitbanging
3856         mov     c,%2
3857         addc    a,r%1
3858         mov     r%1,a
3859 %4:
3860 %3:
3861 } if labelRefCountChange(%3 -1)
3862
3863 // in_byte>>=1; if(in_bit) in_byte|=0x80;
3864 replace {
3865         mov     a,%1
3866         clr     c
3867         rrc     a
3868         mov     %1,a
3869         jnb     %2,%3
3870 %4:
3871         orl     %1,#0x80
3872 %3:
3873 } by {
3874         mov     a,%1
3875         ;       Peephole 258.c  optimized bitbanging
3876         mov     c,%2
3877         rrc     a
3878         mov     %1,a
3879 %4:
3880 %3:
3881 } if notVolatile(%1), labelRefCountChange(%3 -1)
3882
3883 // in_byte>>=1; if(in_bit) in_byte|=0x80;
3884 replace {
3885         mov     a,r%1
3886         clr     c
3887         rrc     a
3888         mov     r%1,a
3889         jnb     %2,%3
3890 %4:
3891         orl     ar%1,#0x80
3892 %3:
3893 } by {
3894         mov     a,r%1
3895         ;       Peephole 258.d  optimized bitbanging
3896         mov     c,%2
3897         rrc     a
3898         mov     r%1,a
3899 %4:
3900 %3:
3901 } if labelRefCountChange(%3 -1)
3902
3903 // out_bit=out_byte&0x80; out_byte<<=1;
3904 // helps f.e. writing data on a 3-wire (SPI) bus
3905 replace {
3906         mov     a,%1
3907         rlc     a
3908         mov     %2,c
3909         mov     a,%1
3910         add     a,%1
3911         mov     %1,a
3912 } by {
3913         mov     a,%1
3914         ;       Peephole 258.e  optimized bitbanging
3915         add     a,%1
3916         mov     %2,c
3917         mov     %1,a
3918 } if notVolatile %1
3919
3920 // out_bit=out_byte&0x01; out_byte>>=1;
3921 replace {
3922         mov     a,%1
3923         rrc     a
3924         mov     %2,c
3925         mov     a,%1
3926         clr     c
3927         rrc     a
3928         mov     %1,a
3929 } by {
3930         mov     a,%1
3931         ;       Peephole 258.f  optimized bitbanging
3932         clr     c
3933         rrc     a
3934         mov     %2,c
3935         mov     %1,a
3936 } if notVolatile %1
3937
3938 // Peepholes 259.x rely on the correct labelRefCount. Otherwise they are
3939 // not compatible with peepholes 250.x
3940 // Peepholes 250.x add jumps to a previously unused label. If the
3941 // labelRefCount is not increased, peepholes 259.x are (mistakenly) applied.
3942 // (Mail on sdcc-devel 2004-10-25)
3943 //
3944 // applies to f.e. vprintf.c
3945 replace {
3946         sjmp    %1
3947 %2:
3948         ret
3949 } by {
3950         sjmp    %1
3951         ;       Peephole 259.a  removed redundant label %2 and ret
3952         ;
3953 } if labelRefCount %2 0
3954
3955 // applies to f.e. gets.c
3956 replace {
3957         ljmp    %1
3958 %2:
3959         ret
3960 } by {
3961         ljmp    %1
3962         ;       Peephole 259.b  removed redundant label %2 and ret
3963         ;
3964 } if labelRefCount %2 0
3965
3966 // optimizing jumptables
3967 // Please note: to enable peephole 260.x you currently have to set
3968 // the environment variable SDCC_SJMP_JUMPTABLE
3969 replace {
3970         add     a,%1
3971         mov     dptr,#%2
3972         jmp     @a+dptr
3973 %2:
3974         ljmp    %5
3975         ljmp    %6
3976         ljmp    %7
3977         ljmp    %8
3978 %3:
3979 } by {
3980         ;       Peephole 260.a  used sjmp in jumptable
3981         mov     dptr,#%2
3982         jmp     @a+dptr
3983 %2:
3984         sjmp    %5
3985         sjmp    %6
3986         sjmp    %7
3987         sjmp    %8
3988 %3:
3989 } if labelJTInRange
3990
3991 // optimizing jumptables
3992 replace {
3993         add     a,%1
3994         mov     dptr,#%2
3995         jmp     @a+dptr
3996 %2:
3997         ljmp    %5
3998         ljmp    %6
3999         ljmp    %7
4000         ljmp    %8
4001         ljmp    %9
4002 %3:
4003 } by {
4004         ;       Peephole 260.b  used sjmp in jumptable
4005         mov     dptr,#%2
4006         jmp     @a+dptr
4007 %2:
4008         sjmp    %5
4009         sjmp    %6
4010         sjmp    %7
4011         sjmp    %8
4012         sjmp    %9
4013 %3:
4014 } if labelJTInRange
4015
4016 // optimizing jumptables
4017 replace {
4018         add     a,%1
4019         mov     dptr,#%2
4020         jmp     @a+dptr
4021 %2:
4022         ljmp    %5
4023         ljmp    %6
4024         ljmp    %7
4025         ljmp    %8
4026         ljmp    %9
4027         ljmp    %10
4028 %3:
4029 } by {
4030         ;       Peephole 260.c  used sjmp in jumptable
4031         mov     dptr,#%2
4032         jmp     @a+dptr
4033 %2:
4034         sjmp    %5
4035         sjmp    %6
4036         sjmp    %7
4037         sjmp    %8
4038         sjmp    %9
4039         sjmp    %10
4040 %3:
4041 } if labelJTInRange
4042
4043 // optimizing jumptables
4044 replace {
4045         add     a,%1
4046         mov     dptr,#%2
4047         jmp     @a+dptr
4048 %2:
4049         ljmp    %5
4050         ljmp    %6
4051         ljmp    %7
4052         ljmp    %8
4053         ljmp    %9
4054         ljmp    %10
4055         ljmp    %11
4056 %3:
4057 } by {
4058         ;       Peephole 260.d  used sjmp in jumptable
4059         mov     dptr,#%2
4060         jmp     @a+dptr
4061 %2:
4062         sjmp    %5
4063         sjmp    %6
4064         sjmp    %7
4065         sjmp    %8
4066         sjmp    %9
4067         sjmp    %10
4068         sjmp    %11
4069 %3:
4070 } if labelJTInRange
4071
4072 // optimizing jumptables
4073 replace {
4074         add     a,%1
4075         mov     dptr,#%2
4076         jmp     @a+dptr
4077 %2:
4078         ljmp    %5
4079         ljmp    %6
4080         ljmp    %7
4081         ljmp    %8
4082         ljmp    %9
4083         ljmp    %10
4084         ljmp    %11
4085         ljmp    %12
4086 %3:
4087 } by {
4088         ;       Peephole 260.e  used sjmp in jumptable
4089         mov     dptr,#%2
4090         jmp     @a+dptr
4091 %2:
4092         sjmp    %5
4093         sjmp    %6
4094         sjmp    %7
4095         sjmp    %8
4096         sjmp    %9
4097         sjmp    %10
4098         sjmp    %11
4099         sjmp    %12
4100 %3:
4101 } if labelJTInRange
4102
4103 // optimizing jumptables
4104 replace {
4105         add     a,%1
4106         mov     dptr,#%2
4107         jmp     @a+dptr
4108 %2:
4109         ljmp    %5
4110         ljmp    %6
4111         ljmp    %7
4112         ljmp    %8
4113         ljmp    %9
4114         ljmp    %10
4115         ljmp    %11
4116         ljmp    %12
4117
4118         ljmp    %13
4119 %3:
4120 } by {
4121         ;       Peephole 260.f  used sjmp in jumptable
4122         mov     dptr,#%2
4123         jmp     @a+dptr
4124 %2:
4125         sjmp    %5
4126         sjmp    %6
4127         sjmp    %7
4128         sjmp    %8
4129         sjmp    %9
4130         sjmp    %10
4131         sjmp    %11
4132         sjmp    %12
4133
4134         sjmp    %13
4135 %3:
4136 } if labelJTInRange
4137
4138 // optimizing jumptables
4139 replace {
4140         add     a,%1
4141         mov     dptr,#%2
4142         jmp     @a+dptr
4143 %2:
4144         ljmp    %5
4145         ljmp    %6
4146         ljmp    %7
4147         ljmp    %8
4148         ljmp    %9
4149         ljmp    %10
4150         ljmp    %11
4151         ljmp    %12
4152
4153         ljmp    %13
4154         ljmp    %14
4155 %3:
4156 } by {
4157         ;       Peephole 260.g  used sjmp in jumptable
4158         mov     dptr,#%2
4159         jmp     @a+dptr
4160 %2:
4161         sjmp    %5
4162         sjmp    %6
4163         sjmp    %7
4164         sjmp    %8
4165         sjmp    %9
4166         sjmp    %10
4167         sjmp    %11
4168         sjmp    %12
4169
4170         sjmp    %13
4171         sjmp    %14
4172 %3:
4173 } if labelJTInRange
4174
4175 // optimizing jumptables
4176 replace {
4177         add     a,%1
4178         mov     dptr,#%2
4179         jmp     @a+dptr
4180 %2:
4181         ljmp    %5
4182         ljmp    %6
4183         ljmp    %7
4184         ljmp    %8
4185         ljmp    %9
4186         ljmp    %10
4187         ljmp    %11
4188         ljmp    %12
4189
4190         ljmp    %13
4191         ljmp    %14
4192         ljmp    %15
4193 %3:
4194 } by {
4195         ;       Peephole 260.h  used sjmp in jumptable
4196         mov     dptr,#%2
4197         jmp     @a+dptr
4198 %2:
4199         sjmp    %5
4200         sjmp    %6
4201         sjmp    %7
4202         sjmp    %8
4203         sjmp    %9
4204         sjmp    %10
4205         sjmp    %11
4206         sjmp    %12
4207
4208         sjmp    %13
4209         sjmp    %14
4210         sjmp    %15
4211 %3:
4212 } if labelJTInRange
4213
4214 // optimizing jumptables
4215 replace {
4216         add     a,%1
4217         mov     dptr,#%2
4218         jmp     @a+dptr
4219 %2:
4220         ljmp    %5
4221         ljmp    %6
4222         ljmp    %7
4223         ljmp    %8
4224         ljmp    %9
4225         ljmp    %10
4226         ljmp    %11
4227         ljmp    %12
4228
4229         ljmp    %13
4230         ljmp    %14
4231         ljmp    %15
4232         ljmp    %16
4233 %3:
4234 } by {
4235         ;       Peephole 260.i  used sjmp in jumptable
4236         mov     dptr,#%2
4237         jmp     @a+dptr
4238 %2:
4239         sjmp    %5
4240         sjmp    %6
4241         sjmp    %7
4242         sjmp    %8
4243         sjmp    %9
4244         sjmp    %10
4245         sjmp    %11
4246         sjmp    %12
4247
4248         sjmp    %13
4249         sjmp    %14
4250         sjmp    %15
4251         sjmp    %16
4252 %3:
4253 } if labelJTInRange
4254
4255 // optimizing jumptables
4256 replace {
4257         add     a,%1
4258         mov     dptr,#%2
4259         jmp     @a+dptr
4260 %2:
4261         ljmp    %5
4262         ljmp    %6
4263         ljmp    %7
4264         ljmp    %8
4265         ljmp    %9
4266         ljmp    %10
4267         ljmp    %11
4268         ljmp    %12
4269
4270         ljmp    %13
4271         ljmp    %14
4272         ljmp    %15
4273         ljmp    %16
4274         ljmp    %17
4275 %3:
4276 } by {
4277         ;       Peephole 260.j  used sjmp in jumptable
4278         mov     dptr,#%2
4279         jmp     @a+dptr
4280 %2:
4281         sjmp    %5
4282         sjmp    %6
4283         sjmp    %7
4284         sjmp    %8
4285         sjmp    %9
4286         sjmp    %10
4287         sjmp    %11
4288         sjmp    %12
4289
4290         sjmp    %13
4291         sjmp    %14
4292         sjmp    %15
4293         sjmp    %16
4294         sjmp    %17
4295 %3:
4296 } if labelJTInRange
4297
4298 // optimizing jumptables
4299 replace {
4300         add     a,%1
4301         mov     dptr,#%2
4302         jmp     @a+dptr
4303 %2:
4304         ljmp    %5
4305         ljmp    %6
4306         ljmp    %7
4307         ljmp    %8
4308         ljmp    %9
4309         ljmp    %10
4310         ljmp    %11
4311         ljmp    %12
4312
4313         ljmp    %13
4314         ljmp    %14
4315         ljmp    %15
4316         ljmp    %16
4317         ljmp    %17
4318         ljmp    %18
4319 %3:
4320 } by {
4321         ;       Peephole 260.k  used sjmp in jumptable
4322         mov     dptr,#%2
4323         jmp     @a+dptr
4324 %2:
4325         sjmp    %5
4326         sjmp    %6
4327         sjmp    %7
4328         sjmp    %8
4329         sjmp    %9
4330         sjmp    %10
4331         sjmp    %11
4332         sjmp    %12
4333
4334         sjmp    %13
4335         sjmp    %14
4336         sjmp    %15
4337         sjmp    %16
4338         sjmp    %17
4339         sjmp    %18
4340 %3:
4341 } if labelJTInRange
4342
4343 // optimizing jumptables
4344 replace {
4345         add     a,%1
4346         mov     dptr,#%2
4347         jmp     @a+dptr
4348 %2:
4349         ljmp    %5
4350         ljmp    %6
4351         ljmp    %7
4352         ljmp    %8
4353         ljmp    %9
4354         ljmp    %10
4355         ljmp    %11
4356         ljmp    %12
4357
4358         ljmp    %13
4359         ljmp    %14
4360         ljmp    %15
4361         ljmp    %16
4362         ljmp    %17
4363         ljmp    %18
4364         ljmp    %19
4365 %3:
4366 } by {
4367         ;       Peephole 260.l  used sjmp in jumptable
4368         mov     dptr,#%2
4369         jmp     @a+dptr
4370 %2:
4371         sjmp    %5
4372         sjmp    %6
4373         sjmp    %7
4374         sjmp    %8
4375         sjmp    %9
4376         sjmp    %10
4377         sjmp    %11
4378         sjmp    %12
4379
4380         sjmp    %13
4381         sjmp    %14
4382         sjmp    %15
4383         sjmp    %16
4384         sjmp    %17
4385         sjmp    %18
4386         sjmp    %19
4387 %3:
4388 } if labelJTInRange
4389
4390 // optimizing jumptables
4391 replace {
4392         add     a,%1
4393         mov     dptr,#%2
4394         jmp     @a+dptr
4395 %2:
4396         ljmp    %5
4397         ljmp    %6
4398         ljmp    %7
4399         ljmp    %8
4400         ljmp    %9
4401         ljmp    %10
4402         ljmp    %11
4403         ljmp    %12
4404
4405         ljmp    %13
4406         ljmp    %14
4407         ljmp    %15
4408         ljmp    %16
4409         ljmp    %17
4410         ljmp    %18
4411         ljmp    %19
4412         ljmp    %20
4413 %3:
4414 } by {
4415         ;       Peephole 260.m  used sjmp in jumptable
4416         mov     dptr,#%2
4417         jmp     @a+dptr
4418 %2:
4419         sjmp    %5
4420         sjmp    %6
4421         sjmp    %7
4422         sjmp    %8
4423         sjmp    %9
4424         sjmp    %10
4425         sjmp    %11
4426         sjmp    %12
4427
4428         sjmp    %13
4429         sjmp    %14
4430         sjmp    %15
4431         sjmp    %16
4432         sjmp    %17
4433         sjmp    %18
4434         sjmp    %19
4435         sjmp    %20
4436 %3:
4437 } if labelJTInRange
4438
4439 // applies to: a = (a << 1) | (a >> 15);
4440 replace {
4441         mov     a,%1
4442         rlc     a
4443         mov     %1,a
4444         mov     a,%2
4445         rlc     a
4446         mov     %2,a
4447         mov     a,%1
4448         mov     acc.0,c
4449         mov     %1,a
4450 } by {
4451         mov     a,%1
4452         rlc     a
4453         ;       Peephole 261.a  optimized left rol
4454         xch     a,%2
4455         rlc     a
4456         xch     a,%2
4457         mov     acc.0,c
4458         mov     %1,a
4459 }
4460
4461 // applies to: a = (a << 15) | (a >> 1);
4462 replace {
4463         mov     a,%1
4464         rrc     a
4465         mov     %1,a
4466         mov     a,%2
4467         rrc     a
4468         mov     %2,a
4469         mov     a,%1
4470         mov     acc.7,c
4471         mov     %1,a
4472 } by {
4473         mov     a,%1
4474         rrc     a
4475         ;       Peephole 261.b  optimized right rol
4476         xch     a,%2
4477         rrc     a
4478         xch     a,%2
4479         mov     acc.7,c
4480         mov     %1,a
4481 }
4482
4483 replace {
4484         cpl     c
4485         cpl     c
4486 } by {
4487         ;       Peephole 262    removed redundant cpl c
4488 }
4489
4490 replace {
4491         mov     %1,#%2
4492         inc     %1
4493         inc     %1
4494         inc     %1
4495 } by {
4496         ;       Peephole 263.a  optimized loading const
4497         mov     %1,#(%2 + 3)
4498 }
4499
4500 replace {
4501         mov     %1,#%2
4502         inc     %1
4503         inc     %1
4504 } by {
4505         ;       Peephole 263.b  optimized loading const
4506         mov     %1,#(%2 + 2)
4507 }
4508
4509 replace {
4510         mov     %1,#%2
4511         inc     %1
4512 } by {
4513         ;       Peephole 263.c  optimized loading const
4514         mov     %1,#(%2 + 1)
4515 }
4516
4517 // should be one of the last peepholes
4518 replace{
4519 %1:
4520 } by {
4521         ;       Peephole 300    removed redundant label %1
4522 } if labelRefCount(%1 0)