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

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