git.gag.com Git - debian/cc1111/blob - src/mcs51/peeph.def

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