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