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

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