peephole.def

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

// custom peephole rules


// replace {
//         mov     %1,dpl
//         mov     (%1 + 1),dph
//         mov     %2,%1
//         mov     (%2 + 1),(%1 + 1)
// } by {
//         ; Peephole 500   removed redundant 16 bit copy via sloc
//         mov     %2,dpl
//         mov     (%2 + 1),dph
// }  // should have a test that %1 is a sloc variable



// replace {
//         mov     %1,dpl
//         mov     (%1 + 1),dph
//         mov     r%2,%1
//         mov     r%3,(%1 + 1)
// } by {
//         ; Peephole 501   removed redundant 16 bit copy via sloc
//         mov     r%2,dpl
//         mov     r%3,dph
// }  // should have a test that %1 is a sloc variable


//replace {
//        movx    a,@dptr
//        mov     %1,a
//        inc     dptr
//        movx    a,@dptr
//        mov     (%1 + 1),a
//        inc     dptr
//        movx    a,@dptr
//        mov     (%1 + 2),a
//        inc     dptr
//        movx    a,@dptr
//        mov     (%1 + 3),a
//        mov     dpl,%1
//        mov     dph,(%1 + 1)
//        mov     b,(%1 + 2)
//        mov     a,(%1 + 3)
//} by {
//        ; Peephole 502   optimized 32 bit xram parameter passing
//        movx    a, @dptr
//        push    acc
//        inc     dptr
//        movx    a, @dptr
//        push    acc
//        inc     dptr
//        movx    a, @dptr
//        mov     b, a
//        inc     dptr
//        movx    a, @dptr
//        pop     dph
//        pop     dpl
//}  // should have a test that %1 is a sloc variable


//replace {
//        mov     dpl,r%3
//        mov     dph,r%4
//        movx    a,@dptr
//        mov     %1,a
//        inc     dptr
//        movx    a,@dptr
//        mov     (%1 + 1),a
//        inc     dptr
//        movx    a,@dptr
//        mov     (%1 + 2),a
//        inc     dptr
//        movx    a,@dptr
//        mov     (%1 + 3),a
//        mov     dpl,%2
//        mov     dph,(%2 + 1)
//        mov     a,%1
//        movx    @dptr,a
//        inc     dptr
//        mov     a,(%1 + 1)
//        movx    @dptr,a
//        inc     dptr
//        mov     a,(%1 + 2)
//        movx    @dptr,a
//        inc     dptr
//        mov     a,(%1 + 3)
//        movx    @dptr,a
//} by {
//	; Peephole 503   32 bit copy using Dual DPTR
//	AUXR1 = 0xA2
//        mov     dpl,r%3
//        mov     dph,r%4
//	inc	AUXR1
//	mov     dpl,%2
//        mov     dph,(%2 + 1)
//	inc	AUXR1
//	movx	a, @dptr
//	inc	dptr
//	inc	AUXR1
//	movx	@dptr, a
//	inc	dptr
//	inc	AUXR1
//	movx	a, @dptr
//	inc	dptr
//	inc	AUXR1
//	movx	@dptr, a
//	inc	dptr
//	inc	AUXR1
//	movx	a, @dptr
//	inc	dptr
//	inc	AUXR1
//	movx	@dptr, a
//	inc	dptr
//	inc	AUXR1
//	movx	a, @dptr
//	inc	AUXR1
//	movx	@dptr, a
//	inc	AUXR1
//}   // should have a test that %1 is a sloc variable
//    // should have a --dual-dptr flag to enable this!


// This will appear built into SDCC soon
replace {
	mov     %1,dpl
        mov     (%1 + 1),dph
        mov     dpl,%1
        mov     dph,(%1 + 1)
} by {
        ; Peephole 600   removed redundant dph/dpl moves
        mov     %1,dpl
        mov     (%1 + 1),dph
}

// This will appear built into SDCC soon
replace {
        clr  a
        movx @dptr,a
        inc  dptr
        movx @dptr,a
        inc     dptr
        clr  a
} by {
	; Peephole 602   removed unnecessary clr
        clr	a
        movx    @dptr,a
        inc     dptr
        movx    @dptr,a
        inc     dptr
}

// This will appear built into SDCC soon
replace {
        mov     dptr,#%1
        clr     a
        inc     dptr
        inc     dptr
        inc     dptr
        movx    @dptr,a
        lcall   __decdptr
        movx    @dptr,a
        lcall   __decdptr
        movx    @dptr,a
        lcall   __decdptr
        movx    @dptr,a
} by {
	; Peephole 603   replaced inefficient 32 bit clear
        mov     dptr,#%1
        clr     a
        movx    @dptr,a
	inc	dptr
        movx    @dptr,a
	inc	dptr
        movx    @dptr,a
	inc	dptr
        movx    @dptr,a
        ;mov     dptr,#%1
}

// This will appear built into SDCC soon
replace {
        mov     dptr,#%1
        clr     a
        inc     dptr
        inc     dptr
        inc     dptr
        movx    @dptr,a
        lcall   __decdptr
        movx    @dptr,a
        lcall   __decdptr
        movx    @dptr,a
        lcall   __decdptr
        mov     a,#%2
        movx    @dptr,a
} by {
	; Peephole 604   replaced inefficient 32 constant
        mov     dptr,#%1
	mov	a, #%2
        movx    @dptr,a
        inc     dptr
        clr     a
        movx    @dptr,a
        inc     dptr
        movx    @dptr,a
        inc     dptr
        movx    @dptr,a
        ;mov     dptr,#%1
}

// This will appear built into SDCC soon
replace {
	mov	dptr,#%1
	clr     a
	inc     dptr
	movx    @dptr,a
	lcall   __decdptr
	movx    @dptr,a
} by {
	; Peephole 605   replaced inefficient 16 bit clear
	mov	dptr,#%1
	clr     a
	movx    @dptr,a
	inc     dptr
	movx    @dptr,a
	;mov	dptr,#%1
}

// This will appear built into SDCC soon
replace {
        mov     dptr,#%1
        clr     a
        inc     dptr
        movx    @dptr,a
        lcall   __decdptr
        mov     a,#%2
        movx    @dptr,a
} by {
	; Peephole 606   replaced inefficient 16 constant
        mov     dptr,#%1
        mov     a,#%2
        movx    @dptr,a
        inc     dptr
        clr     a
        movx    @dptr,a
	;mov	dptr,#%1
}




































replace {
        mov     dptr,#%1
        mov     a,_bp
        add     a,#%2
        mov     r%3,a
        mov     dpl,@r%3
        lcall   %4
} by {
	; Peephole 601   removed unnecessary mov to dptr
        mov     a,_bp
        add     a,#%2
        mov     r%3,a
        mov     dpl,@r%3
        lcall   %4
}

replace {
        mov     r%2,a
        mov     r%3,#0x00
        mov     ar%3,r%2
        mov     r%2,#0x00
} by {
	; Peephole 607   removed unnecessary moves (left shift by 8)
	mov	r%3,a
	mov	r%2,#0x00
}

replace {
        mov     r%2,a
        mov     r%3,#0x00
        mov     r%4,#0x00
        mov     r%5,#0x00
        mov     ar%5,r%3
        mov     ar%4,r%2
        mov     r%3,#0x00
        mov     r%2,#0x00
} by {
	; Peephole 608   removed unnecessary moves (left shift byte by 16)
	mov	r%4,a
	mov	r%2,#0x00
	mov	r%3,#0x00
	mov	r%5,#0x00
}

replace {
        mov     ar%4,r%2
        mov     ar%5,r%3
        mov     r%4,#0x00
        mov     ar%4,r%5
        mov     r%5,#%1
} by {
	; Peephole 609   removed unnecessary moves (right shift by 8)
	mov	ar%4,r%3
	mov	r%5,#%1
}


replace {
        mov     r%4,#0x00
        mov     ar%5,r%3
        mov     ar%4,r%5
        mov     r%5,#%1
} by {
	; Peephole 610   removed unnecessary moves (right shift by 8)
	mov	ar%4,r%3
	mov	r%5,#%1
}

replace {
        mov  r%2,a
        swap    a
        anl     a,#%1
        mov     r%2,a
} by {
	; Peephole 611   removed unnecessary move (shift byte)
        swap    a
        anl     a,#%1
        mov     r%2,a
}

replace {
        mov     r%2,a
        mov     b,#%1
        mov     a,r%2
} by {
        mov     r%2,a
        mov     b,#%1
	; Peephole 612   removed redundant move
}

replace {
        mov     r%2,a
        mov     b,#%1
        mul     ab
        mov     r%2,a
} by {
	; Peephole 613   removed unnecessary move
        mov     b,#%1
        mul     ab
        mov     r%2,a
}

replace {
        mov     r%2,a
        mov     r%3,%1
        mov     a,r%2
} by {
	; Peephole 614   removed redundant move
        mov     r%2,a
        mov     r%3,%1
}

replace {
        mov     r%2,a
        mov     dptr,#%3
        mov     a,r%2
} by {
        mov     r%2,a
        mov     dptr,#%3
	; Peephole 615   removed redundant move
}

replace {
        mov     r%2,a
        mov     dptr,#(%3 + %4)
        mov     a,r%2
} by {
        mov     r%2,a
        mov     dptr,#(%3 + %4)
	; Peephole 616   removed redundant move
}

replace {
        mov     r%2,a
        anl     ar%2,#%1
	cjne	r%2,#%3,%4
} by {
	; Peephole 617   optimized conditional test with logical and
	anl	a,#%1
	mov	r%2,a
	cjne	r%2,#%3,%4
}

replace {
        mov     r%2,dpl
        mov     r%3,dph
        mov     r%4,b
        mov     r%5,a
        mov     %1,r%2
        mov     (%1 + 1),r%3
        mov     (%1 + 2),r%4
        mov     (%1 + 3),r%5
        mov     dpl,%1
        mov     dph,(%1 + 1)
        mov     b,(%1 + 2)
        mov     a,(%1 + 3)
} by {
        mov     r%2,dpl
        mov     r%3,dph
        mov     r%4,b
        mov     r%5,a
        mov     %1,r%2
        mov     (%1 + 1),r%3
        mov     (%1 + 2),r%4
        mov     (%1 + 3),r%5
	; Peephole 618   removed redundant 32 bit move
}

replace {
        mov     r%2,%4
        mov     r%3,%5
        mov     %1,r%2
        mov     (%1 + 1),r%3
        mov     r%2,%1
        mov     r%3,(%1 + 1)
} by {
        mov     r%2,%4
        mov     r%3,%5
        mov     %1,r%2
        mov     (%1 + 1),r%3
	; Peephole 619   removed redundant 16 bit move
}


replace {
        mov     a,(%1 + 3)
        movx    @dptr,a
        mov     dpl,%1
        mov     dph,(%1 + 1)
        mov     b,(%1 + 2)
        mov     a,(%1 + 3)
} by {
        mov     a,(%1 + 3)
        movx    @dptr,a
        mov     dpl,%1
        mov     dph,(%1 + 1)
        mov     b,(%1 + 2)
	; Peephole 620   removed unnecessary mov
}


replace {
        mov     r%4,a
        mov     r%5,#%1
        mov     dptr,#%2
        mov     a,r%4
} by {
        mov     r%4,a
        mov     r%5,#%1
        mov     dptr,#%2
	; Peephole 624  remove unnecessary mov
}

replace {
        mov     r%4,a
        mov     r%5,#%1
        mov     dptr,#(%2 + %3)
        mov     a,r%4
} by {
        mov     r%4,a
        mov     r%5,#%1
        mov     dptr,#(%2 + %3)
	; Peephole 625  remove unnecessary mov
}

replace {
        mov     a,#%1
        movx    @dptr,a
        inc     dptr
        movx    @dptr,a
        inc     dptr
        mov     a,#%1
        movx    @dptr,a
        inc     dptr
        movx    @dptr,a
} by {
        mov     a,#%1
        movx    @dptr,a
        inc     dptr
        movx    @dptr,a
        inc     dptr
        ; Peephole 626  removed redundant mov to a
        movx    @dptr,a
        inc     dptr
        movx    @dptr,a
}

replace {
        mov     r%2,dpl
        mov     r%3,dph
        mov     r%4,b
        mov     r%5,a
        mov     %1,r%2
        mov     (%1 + 1),r%3
        mov     (%1 + 2),r%4
        mov     (%1 + 3),r%5
} by {
        mov     r%2,dpl
        mov     r%3,dph
        mov     r%4,b
        mov     r%5,a
        mov     %1,r%2
        mov     (%1 + 1),r%3
        mov     (%1 + 2),r%4
	; Peephole 627  mov from a, faster than r%5
        mov     (%1 + 3),a
}

replace {
        mov     r%4,a
        mov     r%5,#%1
        mov     %2,r%4
} by {
        mov     r%4,a
        mov     r%5,#%1
	; Peephole 628  mov from a, faster than r%4
        mov     %2,a
}

replace {
        movx    a,@dptr
        mov     r%2,a
        inc     dptr
        movx    a,@dptr
        mov     r%3,a
        mov     a,#%1
        add     a,r%2
        mov     r%2,a
        clr     a
        addc    a,r%3
        mov     r%3,a
} by {
	; Peephole 629  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     r%3,a
}

replace {
        movx    a,@dptr
        mov     r%2,a
        inc     dptr
        movx    a,@dptr
        mov     r%3,a
        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