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

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