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

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