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