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