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