peephole.def

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

        movx    a,@dptr
        mov     r%2,a
        mov     @r%0,a
        inc     r%0
        inc     dptr
        movx    a,@dptr
        mov     r%3,a
        mov     @r%0,a
        inc     r%0
        inc     dptr
        movx    a,@dptr
        mov     r%4,a
        mov     @r%0,a
        inc     r%0
        inc     dptr
        movx    a,@dptr
        mov     r%5,a
        mov     @r%0,a
}


replace {
        jb      %1,%2
        ljmp    %3
%2:
        clr     %1
} by {
        jbc     %1,%2
        ljmp    %3
%2:
	; Peephole 678  remove unnecessary clear (jbc already cleared the bit)
}


replace {
        mov     a,dpl
        mov     b,dph
        add     a,#%1
        mov     r%3,a
        mov     a,b
        addc    a,#%2
        mov     r%4,a
        mov     dpl,r%3
        mov     dph,r%4
        lcall   %5
        mov     r%3,dpl
        mov     r%4,dph
} by {
	; Peephole 679  simplify 16 bit constant added to dptr
        mov     a,dpl
        add     a,#%1
        mov     dpl,a
        mov     a,dph
        addc    a,#%2
        mov     dph,a
        lcall   %5
        mov     r%3,dpl
        mov     r%4,dph
}


replace {
        mov     r%3,dpl
        mov     r%4,dph
        movx    a,@dptr
        mov     r%3,a
        inc     dptr
        movx    a,@dptr
        mov     r%4,a
} by {
        ; Peephole 680  remove unnecessary store to r%3 and r%4
        movx    a,@dptr
        mov     r%3,a
        inc     dptr
        movx    a,@dptr
        mov     r%4,a
}


replace {
        mov     r%1,a
        mov     a,#%2
        add     a,r%1
} by {
        mov     r%1,a
	; Peephole 681  remove unncessary move before add
        add     a,#%2
}


replace {
        mov     r%2,a
        add     a,#%1
        mov     r%2,a
} by {
	; Peephole 682  avoid unnecessary store to r%2
        add     a,#%1
        mov     r%2,a
}


replace {
        mov     r%4,a
        cjne    r%4,#%1,%6
%5:
        mov     r%4,#%2
        sjmp    %7
%6:
        mov     r%4,#%3
%7:
} by {
        mov     r%4,a
        mov     a,#%3
        cjne    r%4,#%1,%6
	; Peephole 683  conditional assignment using conditional addition
        add     a,#(%2 - %3) & 255
%6:
	mov	r%4,a
}


replace {
        mov     r%2,a
        mov     dptr,#%1
        mov     a,r%2
} by {
        mov     r%2,a
        mov     dptr,#%1
        ; Peephole 684  avoid unnecessary mov to a from r%2
}


replace {
        mov     r%1,a
        cjne    r%1,#0x00,%2
        sjmp    %3
%2:
} by {
        mov     r%1,a
	; Peephole 685  replaced cjne(0)/sjmp with jz
	jz      %3
}



replace {
        mov     dptr,#%1
        clr     a
        movx    @dptr,a
        inc     dptr
        movx    @dptr,a
        mov     dptr,#%2
        clr     a
        movx    @dptr,a
} by {
        mov     dptr,#%1
        clr     a
        movx    @dptr,a
        inc     dptr
        movx    @dptr,a
        mov     dptr,#%2
        ; Peephole 686  removed redundant clear
        movx    @dptr,a

}


replace {
        mov     dptr,#%2
        movx    a,@dptr
        mov     r%1,a
        cjne    r%1,#%5,%3
%7:
        mov     dptr,#%2
        clr     a
        movx    @dptr,a
        sjmp    %4
%3:
        mov     dptr,#%2
        mov     a,#%6
        add     a,r%1
        movx    @dptr,a
%4:
} by {
        mov     dptr,#%2
        movx    a,@dptr
        mov     r%1,a
        cjne    r%1,#%5,%3
	; Peephole 687  optimize if eq assign else add sequence
        clr     a
        movx    @dptr,a
        sjmp    %4
%3:
        add     a,#%6
        movx    @dptr,a
%4:
}


replace {
        mov     r%2,a
        cjne    r%2,#0x00,%1
} by {
        mov     r%2,a
	; Peephole 688  replace cjne(0) with jnz
        jnz     %1
}


replace {
        jnz     %1
        mov     a,#0x01
        sjmp    %2
%1:
        clr     a
%2:
        jnz     %3
} by {
	; Peephole 689  optimize if zero test
	jz	%3
}


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
        movx    @dptr,a
        mov     dptr,#%8
        movx    a,@dptr
        mov     r%2,a
        inc     dptr
        movx    a,@dptr
        mov     r%3,a
        mov     dptr,#%1
        movx    a,@dptr
        mov     r%4,a
        inc     dptr
        movx    a,@dptr
        mov     r%5,a
        inc     dptr
        movx    a,@dptr
        mov     r%6,a
        inc     dptr
        movx    a,@dptr
        mov     r%7,a
} by {
        push    acc
        push    b
        push    dph
        mov     a,dpl
        mov     dptr,#%1
        movx    @dptr,a
	; Peephole 690  receive 32 bits to %1 and r%4,r%5,r%6,r%7
        mov     r%4,a
        pop     acc
        inc     dptr
        movx    @dptr,a
        mov     r%5,a
        pop     acc
        inc     dptr
        movx    @dptr,a
        mov     r%6,a
        pop     acc
        inc     dptr
        mov     r%7,a
        movx    @dptr,a
        mov     dptr,#%8
        movx    a,@dptr
        mov     r%2,a
        inc     dptr
        movx    a,@dptr
        mov     r%3,a
}


replace {
        mov     a,#%1
        add     a,%2
        mov     r%3,a
        clr     a
        addc    a,(%2 + 1)
        mov     r%4,a
        mov     dpl,r%3
        mov     dph,r%4
        lcall   %5
        mov     r%3,dpl
        mov     r%4,dph
} by {
        mov     a,#%1
        add     a,%2
        mov     dpl,a
        clr     a
        addc    a,(%2 + 1)
        mov     dph,a
	; Peephole 691  add result directly to dptr instead of r%3,r%4
        lcall   %5
        mov     r%3,dpl
        mov     r%4,dph
}


replace {
        mov     r%3,a
        clr     a
        addc    a,b
        mov     r%4,a
        mov     dpl,r%3
        mov     dph,r%4
        lcall   %1
        movx    a,@dptr
        mov     r%3,a
        inc     dptr
        movx    a,@dptr
        mov     r%4,a
} by {
        mov     dpl,a
        clr     a
        addc    a,b
        mov     dph,a
	; Peephole 692  add result directly to dptr instead of r%3,r%4
        lcall   %1
        movx    a,@dptr
        mov     r%3,a
        inc     dptr
        movx    a,@dptr
        mov     r%4,a
}

replace {
        mov     a,dpl
        mov     b,dph
        add     a,#%3
        mov     dpl,a
        clr     a
        addc    a,b
        mov     dph,a
} by {
        mov     a,dpl
	; Peephole 693  avoid unncessary store of dph in b
        add     a,#%3
        mov     dpl,a
        clr     a
        addc    a,dph
        mov     dph,a
}



replace {
        mov     a,dpl
        mov     b,dph
        add     a,#%1
        mov     r%2,a
        clr     a
        addc    a,b
        mov     r%3,a
} by {
        mov     a,dpl
	; Peephole 694  avoid unncessary store of dph in b
        add     a,#%1
        mov     r%2,a
        clr     a
        addc    a,dph
        mov     r%3,a
}


replace {
        mov     r%2,a
        clr     a
        addc    a,r%3
        mov     r%3,a
        mov     dpl,r%2
} by {
        mov     r%2,a
	; Peephole 695  move to dpl from a instead of r%2 (faster)
        mov     dpl,a
        clr     a
        addc    a,r%3
        mov     r%3,a
}


replace {
        mov     r%2,a
        clr     a
        addc    a,dph
        mov     r%3,a
        mov     dpl,r%2
} by {
        mov     r%2,a
	; Peephole 696  move to dpl from a instead of r%2 (faster)
        mov     dpl,a
        clr     a
        addc    a,dph
        mov     r%3,a
}


replace {
        mov     dptr,#%1
        mov     a,r%2
        movx    @dptr,a
        inc     dptr
        mov     a,r%3
        movx    @dptr,a
        mov     a,#%6
        add     a,r%2
        mov     r%4,a
        clr     a
        addc    a,r%3
        mov     r%5,a
} by {
        mov     dptr,#%1
        mov     a,r%2
        movx    @dptr,a
	; Peephole 697  combine 16 bit store with 8 bit const add
        add     a,#%6
        mov     r%4,a
        inc     dptr
        mov     a,r%3
        movx    @dptr,a
	addc	a,#0
        mov     r%5,a
}






replace {
        mov     r%3,a
        mov     dpl,r%2
        mov     dph,r%3
} by {
        mov     r%3,a
        mov     dpl,r%2
	; Peephole 701  optimize move sequence
        mov     dph,a
}

replace {
        mov     r%2,a
        mov     a,r%2
} by {
	; Peephole 702A  optimize move sequence
        mov     r%2,a
}


replace {
        mov     r%2,a
        mov     %1,r%2
} by {
	; Peephole 702  optimize move sequence
        mov     r%2,a
        mov     %1,a
}

replace {
        mov     ar%3,a
} by {
        ; Peephole 703  move directly to register instead of memory
        mov     r%3,a
}

replace {
	mov	dptr,#%1
        mov     dpl,r%2
        mov     dph,r%3
} by {
	; Peephole 704   removed redundant mov to dptr
        mov     dpl,r%2
        mov     dph,r%3
}


replace {
        movx    a,@dptr
        mov     r%2,a
        inc     dptr
        movx    a,@dptr
        mov     r%3,a
        inc     r%2
        cjne    r%2,#0x00,%1
        inc     r%3
%1:
} by {
        movx    a,@dptr
	; Peephole 705  combine 16 bit read and increment
	add	a,#1
        mov     r%2,a
        inc     dptr
        movx    a,@dptr
	addc	a,#0
        mov     r%3,a
%1:
}


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 706  avoid unnecessary reload of a from r%4
}


replace {
        mov     r%4,a
        mov     a,#%1
        movc    a,@a+dptr
        mov     r%5,a
        mov     r%4,a
} by {
	; Peephole 707  avoid unnecessary store to r%4
        mov     a,#%1
        movc    a,@a+dptr
        mov     r%5,a
        mov     r%4,a
}


replace {
        mov     r%5,a
        mov     r%4,a
        mov     r%5,#%1
} by {
	; Peephole 708  avoid unnecessary move to r%5
        mov     r%4,a
        mov     r%5,#%1
}




// TODO: is this really working in all the places where it should
// This will appear built into SDCC soon
replace {
	mov	dptr,#%1
	mov	dptr,#%2
} by {
	; Peephole 999   removed redundant mov to dptr
	mov	dptr,#%2
}







// This 800 serial peepholes use the Philip Dual-DPTR feature


replace {
        mov     r%2,dpl
        mov     r%3,dph
        mov     dptr,#%1
        mov     a,r%2
        movx    @dptr,a
        inc     dptr
        mov     a,r%3
        movx    @dptr,a
        mov     dpl,r%2
        mov     dph,r%3
} by {
        mov     r%2,dpl
        mov     r%3,dph
        inc     0xA2
        ; Peephole 800  preserve dptr using philips dual-dptr
        mov     dptr,#%1
        mov     a,r%2
        movx    @dptr,a
        inc     dptr
        mov     a,r%3
        movx    @dptr,a
        inc     0xA2
}