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