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

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