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