peephole.def

一款MP3 Player Firmware 的原代码,非常有参考价值

        movx    a,@dptr
        mov     r%3,a
} by {
	; Peephole 630  combine 16 bit fetch with 8 bit const addition
        movx    a,@dptr
        add     a,#%1
        mov     r%2,a
        inc     dptr
        movx    a,@dptr
        addc    a,#0
        mov     dph,a
        mov     dpl,r%2
        movx    a,@dptr
        mov     r%2,a
        inc     dptr
        movx    a,@dptr
        mov     r%3,a
}

replace {
        mov     dptr,#%1
        movx    a,@dptr
        mov     r%2,a
        inc     dptr
        movx    a,@dptr
        mov     r%3,a
        mov     dptr,#%1
        mov     a,#0x01
        add     a,r%2
        movx    @dptr,a
        clr     a
        addc    a,r%3
        inc     dptr
        movx    @dptr,a
} by {
	; Peephole 631  optimize 16 bit increment
        mov     dptr,#%1
        movx    a,@dptr
        mov     r%2,a
        add     a,#1
        movx    @dptr,a
        inc     dptr
        movx    a,@dptr
        mov     r%3,a
        addc    a,#0
        movx    @dptr,a
}

// TODO: fixme   why do this not match patterns in dirlist.c
replace {
	; Peephole 632  combine 32 bit fetch with 32 bit const addition
        movx    a,@dptr
        mov     r%2,a
        inc     dptr
        movx    a,@dptr
        mov     r%3,a
        inc     dptr
        movx    a,@dptr
        mov     r%4,a
        inc     dptr
        movx    a,@dptr
        mov     r%5,a
        mov     a,r%2
        add     a,#%6
        mov     r%2,a
        mov     a,r%3
        addc    a,#%7
        mov     r%3,a
        mov     a,r%4
        addc    a,#%8
        mov     r%4,a
        mov     a,r%5
        addc    a,#%9
        mov     r%5,a
} by {
        movx    a,@dptr
        add     a,#%6
        mov     r%2,a
        inc     dptr
        movx    a,@dptr
        addc    a,#%7
        mov     r%3,a
        inc     dptr
        movx    a,@dptr
        addc    a,#%8
        mov     r%4,a
        inc     dptr
        movx    a,@dptr
        addc    a,#%9
        mov     r%5,a
}

replace {
        mov     a,%2
        add     a,#0x00
        mov     %2,a
        mov     a,%3
        addc    a,#%5
        mov     %3,a
} by {
        ; Peephole 633  optimize 16 bit const addition with LSB=0
        mov     a,%3
        add     a,#%5
        mov     %3,a
}


replace {
        mov     a,%1
        add     a,#0x00
        mov     %1,a
        mov     a,(%1 + 1)
        addc    a,#%5
        mov     (%1 + 1),a
} by {
        ; Peephole 634  optimize 16 bit const addition with LSB=0
        mov     a,(%1 + 1)
        add     a,#%5
        mov     (%1 + 1),a
}


replace {
        mov     dptr,#%1
        movx    a,@dptr
        mov     r%2,a
        inc     dptr
        movx    a,@dptr
        mov     r%3,a
        dec     r%2
        cjne    r%2,#0xff,%5
        dec     r%3
%5:
        mov     dptr,#%1
        mov     a,r%2
        movx    @dptr,a
        inc     dptr
        mov     a,r%3
        movx    @dptr,a
} by {
        ; Peephole 635  optimize 16 bit decrement
        mov     dptr,#%1
        movx    a,@dptr
        add     a,#0xff
        movx    @dptr,a
        mov     r%2,a
        inc     dptr
        movx    a,@dptr
        addc    a,#0xff
        movx    @dptr,a
        mov     r%3,a
}


replace {
        mov     dptr,#%1
        movx    a,@dptr
        mov     r%2,a
        dec     a
        mov     dptr,#%1
} by {
        mov     dptr,#%1
        movx    a,@dptr
        mov     r%2,a
        dec     a
        ; Peephole 636  removed unnecessary mov to dptr
}


// Frieder Ferlemann says restart is not necessary on this one
replace restart {
        mov     dptr,#%1
        movx    a,@dptr
        mov     r%2,a
        dec     r%2
        mov     dptr,#%1
        mov     a,r%2
        movx    @dptr,a
} by {
        ; Peephole 637  optimize 8 bit decrement
        mov     dptr,#%1
        movx    a,@dptr
        dec     a
        movx    @dptr,a
        mov     r%2,a
}


replace restart {
        mov     dptr,#(%1 + %5)
        movx    a,@dptr
        mov     r%2,a
        dec     r%2
        mov     dptr,#(%1 + %5)
        mov     a,r%2
        movx    @dptr,a
} by {
        ; Peephole 638  optimize 8 bit decrement
        mov     dptr,#(%1 + %5)
        movx    a,@dptr
        dec     a
        movx    @dptr,a
        mov     r%2,a
}

replace restart {
        mov     dptr,#%1
        movx    a,@dptr
        inc     a
        mov     r%2,a
        mov     dptr,#%1
        movx    @dptr,a
} by {
        ; Peephole 639  optimize 8 bit increment
        mov     dptr,#%1
        movx    a,@dptr
        inc     a
        movx    @dptr,a
        mov     r%2,a
}

replace restart {
        mov     dptr,#(%1 + %5)
        movx    a,@dptr
        inc     a
        mov     r%2,a
        mov     dptr,#(%1 + %5)
        movx    @dptr,a
} by {
        ; Peephole 640  optimize 8 bit increment
        mov     dptr,#(%1 + %5)
        movx    a,@dptr
        inc     a
        movx    @dptr,a
        mov     r%2,a
}


replace restart {
        mov     dptr,#%1
        movx    a,@dptr
        add     a,#0x01
        mov     r2,a
        mov     dptr,#%1
        movx    @dptr,a
} by {
        ; Peephole 641  optimize 8 bit pre-increment
        mov     dptr,#%1
        movx    a,@dptr
        add     a,#0x01
        movx    @dptr,a
        mov     r2,a
}

replace restart {
        mov     dptr,#(%1 + %5)
        movx    a,@dptr
        add     a,#0x01
        mov     r2,a
        mov     dptr,#(%1 + %5)
        movx    @dptr,a
} by {
        ; Peephole 642  optimize 8 bit pre-increment
        mov     dptr,#(%1 + %5)
        movx    a,@dptr
        add     a,#0x01
        movx    @dptr,a
        mov     r2,a
}



replace restart {
        mov     dptr,#%1
        movx    a,@dptr
        mov     r%2,a
        inc     dptr
        movx    a,@dptr
        mov     r%3,a
        inc     r%2
        cjne    r%2,#0x00,%5
        inc     r%3
%5:
        mov     dptr,#%1
        mov     a,r%2
        movx    @dptr,a
        inc     dptr
        mov     a,r%3
        movx    @dptr,a
} by {
        ; Peephole 643  optimize 16 bit increment
        mov     dptr,#%1
        movx    a,@dptr
        add     a,#1
        movx    @dptr,a
        mov     r%2,a
        inc     dptr
        movx    a,@dptr
        addc    a,#0
        movx    @dptr,a
        mov     r%3,a
}



replace restart {
        mov     dptr,#(%1 + %4)
        movx    a,@dptr
        mov     r%2,a
        inc     dptr
        movx    a,@dptr
        mov     r%3,a
        inc     r%2
        cjne    r%2,#0x00,%5
        inc     r%3
%5:
        mov     dptr,#(%1 + %4)
        mov     a,r%2
        movx    @dptr,a
        inc     dptr
        mov     a,r%3
        movx    @dptr,a
} by {
        ; Peephole 644  optimize 16 bit increment
        mov     dptr,#(%1 + %4)
        movx    a,@dptr
        add     a,#1
        movx    @dptr,a
        mov     r%2,a
        inc     dptr
        movx    a,@dptr
        addc    a,#0
        movx    @dptr,a
        mov     r%3,a
}

replace {
        mov     dptr,#%1
        movx    a,@dptr
        mov     r%2,a
        mov     dptr,#%1
        mov     a,#0x01
        add     a,r%2
        movx    @dptr,a
} by {
        ; Peephole 645  optimize 8 bit increment
        mov     dptr,#%1
        movx    a,@dptr
        mov     r%2,a
        add     a,#1
        movx    @dptr,a
}

replace {
        mov     dptr,#(%1 + %5)
        movx    a,@dptr
        mov     r%2,a
        mov     dptr,#(%1 + %5)
        mov     a,#0x01
        add     a,r%2
        movx    @dptr,a
} by {
        ; Peephole 646  optimize 8 bit increment
        mov     dptr,#(%1 + %5)
        movx    a,@dptr
        mov     r%2,a
        add     a,#1
        movx    @dptr,a
}


replace {
        mov     r%2,#%1
        mov     ar%2,r%3
} by {
        ; Peephole 647  removed unnecessary move to r%2
        mov     ar%2,r%3
}

// removed this one... whatever follows at %5 might depend on
// the carry bit from the CJNE instruction
// this depends on peephole 132 to make the sjmp
//replace {
//        mov     r%2,a
//        cjne    r%2,#0x00,%5
//        sjmp    %4
//%5:
//} by {
//        mov     r%2,a
//        ; Peephole 648  optimized zero test
//        jz      %4
//%5:
//}


// Frieder Ferlemann says restart is not necessary on this one
replace {
        mov     a,r%2
        add     a,#%1
        mov     r%3,a
        clr     a
        addc    a,#(%1 >> 8)
        mov     r%4,a
        mov     a,r%3
        add     a,#%5
        mov     r%3,a
        mov     a,r%4
        addc    a,#%6
        mov     r%4,a
} by {
        mov     a,r%2
        ; Peephole 649  combined 16 bit immediate adds
        add     a,#(%1 + (%6 << 8) + %5)
        mov     r%3,a
        clr     a
        addc    a,#((%1 + (%6 << 8) + %5) >> 8)
        mov     r%4,a
}


replace {
        push    dpl
        mov     dptr,#%1
        pop     acc
        movx    @dptr,a
} by {
        ; Peephole 650  avoid unnecessary push/pop moving dpl to acc
        mov     a,dpl
        mov     dptr,#%1
        movx    @dptr,a
}



replace {
        mov     r%2,a
        dec     r%2
        mov     a,r%2
} by {
	; Peephole 651  optimize 8 bit decrement
	dec	a
	mov	r%2,a
}


replace {
        mov     a,r%2
        movx    @dptr,a
        mov     a,r%2
} by {
        mov     a,r%2
        movx    @dptr,a
	; Peephole 652  removed redundant mov
}


replace {
        movx    a,@dptr
        mov     r%2,a
        inc     dptr
        movx    a,@dptr
        mov     r%3,a
        inc     dptr
        movx    a,@dptr
        mov     r%4,a
        inc     dptr
        movx    a,@dptr
        mov     r%5,a
        mov     ar%6,r%2
        mov     ar%7,r%3
        mov     ar%0,r%4
        mov     ar%1,r%5
} by {
        ; Peephole 653  improve 32 bit load to two register groups
        movx    a,@dptr
        mov     r%2,a
        mov     r%6,a
        inc     dptr
        movx    a,@dptr
        mov     r%3,a
        mov     r%7,a
        inc     dptr
        movx    a,@dptr
        mov     r%4,a
        mov     r%0,a
        inc     dptr
        movx    a,@dptr
        mov     r%5,a
        mov     r%1,a
}

replace {
        mov     dptr,#%1
        movx    a,@dptr
        add     a,#%4
        mov     r%2,a
        inc     dptr
        movx    a,@dptr
        addc    a,#%5
        mov     r%3,a
        mov     dptr,#%1
        mov     a,r%2
        movx    @dptr,a
        inc     dptr
        mov     a,r%3
        movx    @dptr,a
} by {
        ; Peephole 654  optimized 16 bit constant addition
        mov     dptr,#%1
        movx    a,@dptr
        add     a,#%4
        movx    @dptr,a
        mov     r%2,a
        inc     dptr
        movx    a,@dptr
        addc    a,#%5
        movx    @dptr,a
        mov     r%3,a
}

// This does not work.  The code following at %4 will sometimes
// depend on the value of the varry bit from CJNE
//replace {
//        mov     r%2,a
//	cjne	r%2,#0x00,%4
//} by {
//	; Peephole 655  replaced cjne with jnz (saves 1 byte code)  
//        mov     r%2,a
//        jnz     %4
//}


; TODO: does the peephole optimizer check that %1 isn't "volatile" ???

replace {
        mov     dptr,#%1
        movx    @dptr,a
        mov     dptr,#%1
        movx    a,@dptr
} by {
        mov     dptr,#%1
        movx    @dptr,a
        ; Peephole 656  avoid re-reading what was just written
}

replace {
        mov     r%2,a
        clr     %1
        mov     a,r%2
} by {
        mov     r%2,a
        clr     %1
        ; Peephole 657  remove unnecessary read from r%2 (value already in acc)
}


replace {
        push    dph
        mov     a,dpl
        mov     dptr,#%1
        movx    @dptr,a
        pop     acc
        inc     dptr
        movx    @dptr,a
        mov     dptr,#%1
        movx    a,@dptr
        mov     r%2,a
        inc     dptr
        movx    a,@dptr
        mov     r%3,a
} by {
        push    dph
        mov     a,dpl
        mov     dptr,#%1
        movx    @dptr,a
	; Peephole 658  merge 16-bit genReceive with genAssign to registers
        mov     r%2,a
        pop     acc
        inc     dptr
        movx    @dptr,a
        mov     r%3,a
}



replace {
        push    acc
        push    b
        push    dph
        mov     a,dpl
        mov     dptr,#%1
        movx    @dptr,a
        pop     acc
        inc     dptr
        movx    @dptr,a
        pop     acc
        inc     dptr
        movx    @dptr,a
        pop     acc
        inc     dptr