peephole.def

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

        movx    @dptr,a
        mov     dptr,#%1
        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
} by {
        push    acc
        push    b
        push    dph
        mov     a,dpl
        mov     dptr,#%1
        movx    @dptr,a
	; Peephole 659  merge 32-bit genReceive with genAssign to registers
        mov     r%2,a
        pop     acc
        inc     dptr
        movx    @dptr,a
        mov     r%3,a
        pop     acc
        inc     dptr
        movx    @dptr,a
        mov     r%4,a
        pop     acc
        inc     dptr
        movx    @dptr,a
        mov     r%5,a
}


replace {
        mov     a,dpl
        mov     b,dph
        mov     %2,a
        mov     (%2 + 1),b
        mov     a,#%1
        add     a,%2
        mov     dpl,a
        clr     a
        addc    a,(%2 + 1)
        mov     dph,a
} by {
        mov     a,dpl
	; Peephole 660  merge 16 bit return with assignment and 8 bit add
        mov     %2,a
	add	a,#%1
	mov	dpl,a
	mov	a,dph
	mov	(%2 + 1),a
	addc	a,#0
	mov	dph,a
}




replace {
        mov     a,r%2
        movx    @dptr,a
        inc     dptr
        mov     a,r%3
        movx    @dptr,a
        mov     a,#%1
        add     a,r%2
        mov     r%2,a
        clr     a
        addc    a,r%3
        mov     r%3,a
} by {
        mov     a,r%2
        movx    @dptr,a
	; Peephole 661  merge 16 bit data store with 8 bit add
	add	a,#%1
	mov	r%2,a
        inc     dptr
        mov     a,r%3
        movx    @dptr,a
        addc    a,#0
        mov     r%3,a
}

replace {
        mov     dptr,#%1
        movx    a,@dptr
        add     a,#%3
        mov     r%2,a
        mov     dptr,#%1
        movx    @dptr,a
} by {
        mov     dptr,#%1
        movx    a,@dptr
        add     a,#%3
        mov     r%2,a
	; Peephole 662  removed redundant initialization of dptr
        movx    @dptr,a
}

replace {
        mov     r%2,dpl
        mov     r%3,dph
        inc     r%2
        cjne    r%2,#0x00,%1
        inc     r%3
%1:
        mov     dpl,r%2
        mov     dph,r%3
} by {
	; Peephole 663  optimize 16 bit increment
	inc	dptr
        mov     r%2,dpl
        mov     r%3,dph
%1:
}




replace {
        mov     dptr,#%2
        movx    a,@dptr
        mov     r%6,a
        inc     dptr
        movx    a,@dptr
        mov     r%7,a
        inc     dptr
        movx    a,@dptr
        mov     r%0,a
        inc     dptr
        movx    a,@dptr
        mov     r%1,a
        mov     dpl,r4
        mov     dph,r5
        mov     a,r%6
        movx    @dptr,a
        inc     dptr
        mov     a,r%7
        movx    @dptr,a
        inc     dptr
        mov     a,r%0
        movx    @dptr,a
        inc     dptr
        mov     a,r%1
        movx    @dptr,a
        mov     dptr,#%2
        mov     a,%3
        movx    @dptr,a
        inc     dptr
        mov     a,(%3 + 1)
        movx    @dptr,a
        inc     dptr
        mov     a,(%3 + 2)
        movx    @dptr,a
        inc     dptr
        mov     a,(%3 + 3)
        movx    @dptr,a
} by {
        mov     dptr,#%2
        movx    a,@dptr
        mov     r%6,a
	; Peephole 664  combine 32 bit read/write of same variable
        mov     a,%3
        movx    @dptr,a
        inc     dptr
        movx    a,@dptr
        mov     r%7,a
        mov     a,(%3 + 1)
        movx    @dptr,a
        inc     dptr
        movx    a,@dptr
        mov     r%0,a
        mov     a,(%3 + 2)
        movx    @dptr,a
        inc     dptr
        movx    a,@dptr
        mov     r%1,a
        mov     a,(%3 + 3)
        movx    @dptr,a
        mov     dpl,r4
        mov     dph,r5
        mov     a,r%6
        movx    @dptr,a
        inc     dptr
        mov     a,r%7
        movx    @dptr,a
        inc     dptr
        mov     a,r%0
        movx    @dptr,a
        inc     dptr
        mov     a,r%1
        movx    @dptr,a
}



replace {
        mov     dptr,#%5
        movx    a,@dptr
        mov     r%4,a
        mov     dptr,#%6
        mov     a,%1
        movx    @dptr,a
        inc     dptr
        mov     a,(%1 + 1)
        movx    @dptr,a
        mov     dpl,r%4
        push    %2
        push    %3
        lcall   %7
        mov     r%4,dpl
} by {
        mov     dptr,#%6
        mov     a,%1
        movx    @dptr,a
        inc     dptr
        mov     a,(%1 + 1)
        movx    @dptr,a
	; Peephole 665  optimize parameter passing to function
        mov     dptr,#%5
        movx    a,@dptr
        mov     dpl,a
        push    %2
        push    %3
        lcall   %7
        mov     r%4,dpl
}


replace {
        mov     r%6,a
        mov     r%7,#0x00
        mov     dpl,a
        mov     dph,r%7
        push    %1
        push    %2
        push    %3
        push    %4
        lcall   %5
        mov     r%6,dpl
        mov     r%7,dph
} by {
	; Peephole 666  optimize parameter passing to function
        mov     dpl,a
        mov     dph,#0
        push    %1
        push    %2
        push    %3
        push    %4
        lcall   %5
        mov     r%6,dpl
        mov     r%7,dph
}


replace {
        mov     a,dpl
        mov     b,dph
        mov     %1,a
        mov     (%1 + 1),b
        mov     a,#%0
        add     a,%1
        mov     r%6,a
        clr     a
        addc    a,(%1 + 1)
        mov     r%7,a
        push    %2
        push    %3
        mov     dpl,r%4
        mov     dph,r%5
} by {
        mov     a,dpl
        mov     %1,a
	; Peephole 667  optimize move and add
	add	a,#%0
        mov     r%6,a
        mov     a,dph
        mov     (%1 + 1),a
        addc    a,#0
        mov     r%7,a
        push    %2
        push    %3
        mov     dpl,r%4
        mov     dph,r%5
}

replace {
        mov     dpl,r%4
        mov     dph,r%5
        movx    a,@dptr
        mov     r%0,a
        inc     dptr
        movx    a,@dptr
        mov     r%1,a
        inc     dptr
        movx    a,@dptr
        mov     r%2,a
        inc     dptr
        movx    a,@dptr
        mov     r%3,a
        mov     dpl,r%6
        mov     dph,r%7
        mov     a,r%0
        movx    @dptr,a
        inc     dptr
        mov     a,r%1
        movx    @dptr,a
        inc     dptr
        mov     a,r%2
        movx    @dptr,a
        inc     dptr
        mov     a,r%3
        movx    @dptr,a
        mov     dpl,r%4
        mov     dph,r%5
        mov     a,%8
        movx    @dptr,a
        inc     dptr
        mov     a,(%8 + 1)
        movx    @dptr,a
        inc     dptr
        mov     a,(%8 + 2)
        movx    @dptr,a
        inc     dptr
        mov     a,(%8 + 3)
        movx    @dptr,a
} by {
        mov     dpl,r%4
        mov     dph,r%5
        movx    a,@dptr
        mov     r%0,a
	; Peephole 668  combine 32 bit read/write of same variable
        mov     a,%8
        movx    @dptr,a
        inc     dptr
        movx    a,@dptr
        mov     r%1,a
        mov     a,(%8 + 1)
        movx    @dptr,a
        inc     dptr
        movx    a,@dptr
        mov     r%2,a
        mov     a,(%8 + 2)
        movx    @dptr,a
        inc     dptr
        movx    a,@dptr
        mov     r%3,a
        mov     a,(%8 + 3)
        movx    @dptr,a
        mov     dpl,r%6
        mov     dph,r%7
        mov     a,r%0
        movx    @dptr,a
        inc     dptr
        mov     a,r%1
        movx    @dptr,a
        inc     dptr
        mov     a,r%2
        movx    @dptr,a
        inc     dptr
        mov     a,r%3
        movx    @dptr,a
}


replace {
        mov     dptr,#%1
        movx    a,@dptr
        mov     r%2,a
        inc     dptr
        movx    a,@dptr
        mov     r%3,a
        mov     dptr,#%0
        mov     a,r%6
        movx    @dptr,a
        inc     dptr
        mov     a,r%7
        movx    @dptr,a
        mov     dptr,#%1
        mov     a,r%4
        movx    @dptr,a
        inc     dptr
        mov     a,r%5
        movx    @dptr,a
} by {
        mov     dptr,#%1
        movx    a,@dptr
        mov     r%2,a
	; Peephole 669  combine 16 bit read/write of same variable
        mov     a,r%4
        movx    @dptr,a
        inc     dptr
        movx    a,@dptr
        mov     r%3,a
        mov     a,r%5
        movx    @dptr,a
        mov     dptr,#%0
        mov     a,r%6
        movx    @dptr,a
        inc     dptr
        mov     a,r%7
        movx    @dptr,a
}




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


replace {
        mov     dptr,#%1
        movx    a,@dptr
        mov     r%4,a
        inc     dptr
        movx    a,@dptr
        mov     r%5,a
        mov     a,r%6
        add     a,r%4
        mov     r%4,a
        mov     a,r%7
        addc    a,r%5
        mov     r%5,a
        mov     dptr,#%1
        mov     a,r%4
        movx    @dptr,a
        inc     dptr
        mov     a,r%5
        movx    @dptr,a
} by {
	; Peephole 671  optimize 16 bit add to external memory
        mov     dptr,#%1
        movx    a,@dptr
	add	a,r%6
	mov	r%4,a
        movx    @dptr,a
	inc	dptr
        movx    a,@dptr
	addc	a,r%7
	mov	r%5,a
        movx    @dptr,a
}


replace {
        mov     r%5,a
        mov     a,r%2
        orl     a,r%3
        orl     a,r%4
        orl     a,r%5
} by {
        mov     r%5,a
	; Peephole 672  reorder 32 bit OR (saves one mov)
        orl     a,r%2
        orl     a,r%3
        orl     a,r%4
}



replace {
        mov     r%2,dpl
        mov     r%3,dph
        mov     a,#%1
        add     a,r%2
        mov     dpl,a
        clr  a  
        addc    a,r%3
        mov     dph,a
        movx    a,@dptr
        mov     r%2,a
        inc     dptr
        movx    a,@dptr
        mov     r%3,a
} by {
	; Peephole 673  eliminate unneeded storage of pointer into registers
	mov	a,#%1
	add	a, dpl
	mov	dpl, a
	clr	a
	addc	a, dph
	mov	dph, a
        movx    a,@dptr
        mov     r%2,a
        inc     dptr
        movx    a,@dptr
        mov     r%3,a
}

replace {
        mov     (%1 + 2),a
        inc     dptr
        movx    a,@dptr
        mov     (%1 + 3),a
        mov     dpl,%1
        mov     dph,(%1 + 1)
        mov     b,(%1 + 2)
} by {
        mov     (%1 + 2),a
	; Peephole 674  mov into b early (directly from a)
        mov     b, a
        inc     dptr
        movx    a,@dptr
        mov     (%1 + 3),a
        mov     dpl,%1
        mov     dph,(%1 + 1)
}

replace {
        mov     r%4,a
        inc     dptr
        movx    a,@dptr
        mov     r%5,a
        mov     dpl,r%2
        mov     dph,r%3
        mov     b,r%4
} by {
        mov     r%4,a
	; Peephole 675  mov into b early (directly from a)
        mov     b, a
        inc     dptr
        movx    a,@dptr
        mov     r%5,a
        mov     dpl,r%2
        mov     dph,r%3
}

replace {
        mov     r5,a
        mov     a,r2
        cjne    a,%1,00110$
        mov     a,r3
        cjne    a,(%1 + 1),00110$
        mov     a,r4
        cjne    a,(%1 + 2),00110$
        mov     a,r5
        cjne    a,(%1 + 3),00110$
} by {
        mov     r5,a
	; Peephole 676  reorder 32 bit compare (saves one mov)
        cjne    a,(%1 + 3),00110$
        mov     a,r2
        cjne    a,%1,00110$
        mov     a,r3
        cjne    a,(%1 + 1),00110$
        mov     a,r4
        cjne    a,(%1 + 2),00110$
}


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     r%0,_bp
        inc     r%0
        mov     @r%0,ar%2
        inc     r%0
        mov     @r%0,ar%3
        inc     r%0
        mov     @r%0,ar%4
        inc     r%0
        mov     @r%0,ar%5
} by {
	; Peephole 677  merge 32 bit xdata read with 32 bit stack write
        mov     r%0,_bp
        inc     r%0