URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [newlib-1.17.0/] [newlib/] [libc/] [machine/] [z8k/] [memmove.S] - Blame information for rev 862

Go to most recent revision | Details | Compare with Previous | View Log


/*
 * memmove routine for Z8000
 * Copyright (C) 2004 Christian Groessler 
 *
 * Permission to use, copy, modify, and distribute this file
 * for any purpose is hereby granted without fee, provided that
 * the above copyright notice and this notice appears in all
 * copies.
 *
 * This file is distributed WITHOUT ANY WARRANTY; without even the implied
 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 */
 
/* void *memmove(void *dest, const void *src, size_t length);
 */
 
        name    "memmove.S"
 
        .text
        even
global  _memmove
 
_memmove:
 
#ifdef __Z8001__
        segm
 
#ifdef __STD_CALL__
        ldl     rr6,rr14(#4)
        ldl     rr4,rr14(#8)
        ldl     rr2,rr14(#12)
#else
        pushl   @rr14,rr6
#endif
 
/* rr2  - length        (high word ignored)
 * rr4  - src
 * rr6  - dest
 */
 
        testl   rr2
        jr      z,finish
 
/*  check for destructive overlap (src < dest && dest < src + length) */
 
        cpl     rr6,rr4
        jp      ule,memmove_entry       /* non-destructive, let memcpy do the work */
        ldl     rr0,rr2
        addl    rr0,rr4                 /* rr0 = src + length */
        cpl     rr0,rr6
        jp      ult,memmove_entry       /* non-destructive, let memcpy do the work */
 
/* set-up pointers to copy backwards, add (length - 1) */
        addl    rr4,rr2                 /* src + length */
        addl    rr6,rr2                 /* dest + length */
        subl    rr4,#1
        subl    rr6,#1
 
/* check alignment */
        bitb    rl7,#0          /* odd destination address? */
        jr      z,testsrc
        bitb    rl5,#0          /* odd source address? */
        jr      z,odd_copy
        jr      even_copy
 
testsrc:
        bitb    rl5,#0
        jr      nz,odd_copy     /* src even, dest odd */
        lddb    @rr6,@rr4,r3
        jr      ov,finish       /* jump if r5 is zero now */
 
/* copy words */
even_copy:
        ld      r2,r3                   /* remember length */
        srl     r3,#1
/*      jr      z,no_words         it cannot be zero here */
 
        dec     r5,#1
        dec     r7,#1
        lddr    @rr6,@rr4,r3
 
no_words:
        bitb    rl2,#0          /* odd length? */
        jr      z,finish
        inc     r5,#1
        inc     r7,#1
        lddb    @rr6,@rr4,r2    /* yes, copy last byte */
        jr      finish
 
/* copy bytes */
odd_copy:
        lddrb   @rr6,@rr4,r3
 
finish:
#ifdef __STD_CALL__
        ldl     rr6,rr14(#4)
#else
        popl    rr2,@rr14
#endif
 
 
#else           /* above Z8001, below Z8002 */
 
 
        unsegm
 
#ifdef __STD_CALL__
        ld      r7,r15(#2)
        ld      r6,r15(#4)
        ld      r5,r15(#6)
#else
        ld      r2,r7           /* buffer pointer return value */
#endif
 
/* r5  - length
 * r6  - src
 * r7  - dest
 */
        test    r5
        jr      z,finish
 
/*  check for destructive overlap (src < dest && dest < src + length) */
 
        cp      r7,r6
        jp      ule,memmove_entry       /* non-destructive, let memcpy do the work */
        ld      r0,r5
        add     r0,r6                   /* r0 = src + length */
        cp      r0,r7
        jp      ult,memmove_entry       /* non-destructive, let memcpy do the work */
 
/* set-up pointers to copy backwards, add (length - 1) */
        add     r6,r5                   /* src + length */
        add     r7,r5                   /* dest + length */
        dec     r6,#1
        dec     r7,#1
 
/* check alignment */
        bitb    rl7,#0          /* odd destination address? */
        jr      z,testsrc
        bitb    rl6,#0          /* odd source address? */
        jr      z,odd_copy
        jr      even_copy
 
testsrc:
        bitb    rl6,#0
        jr      nz,odd_copy     /* src even, dest odd */
        lddb    @r7,@r6,r5
        jr      ov,finish       /* jump if r5 is zero now */
 
/* copy words */
even_copy:
        ld      r4,r5           /* remember length */
        srl     r5,#1
/*      jr      z,no_words         it cannot be zero here */
 
        dec     r6,#1
        dec     r7,#1
        lddr    @r7,@r6,r5
 
no_words:
        bitb    rl4,#0          /* odd length? */
        jr      z,finish
        inc     r6,#1
        inc     r7,#1
        lddb    @r7,@r6,r4      /* yes, copy last byte */
        jr      finish
 
/* copy bytes */
odd_copy:
        lddrb   @r7,@r6,r5
 
finish:
#ifdef __STD_CALL__
        ld      r7,r15(#2)
#endif
 
#endif  /* Z8002 */
 
        ret
        .end

Line No.	Rev	Author	Line
1	148	jeremybenn	`/*`
2			`* memmove routine for Z8000`
3			`* Copyright (C) 2004 Christian Groessler`
4			`*`
5			`* Permission to use, copy, modify, and distribute this file`
6			`* for any purpose is hereby granted without fee, provided that`
7			`* the above copyright notice and this notice appears in all`
8			`* copies.`
9			`*`
10			`* This file is distributed WITHOUT ANY WARRANTY; without even the implied`
11			`* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.`
12			`*/`
13
14			`/* void memmove(void dest, const void *src, size_t length);`
15			`*/`
16
17			`name "memmove.S"`
18
19			`.text`
20			`even`
21			`global _memmove`
22
23			`_memmove:`
24
25			`#ifdef __Z8001__`
26			`segm`
27
28			`#ifdef __STD_CALL__`
29			`ldl rr6,rr14(#4)`
30			`ldl rr4,rr14(#8)`
31			`ldl rr2,rr14(#12)`
32			`#else`
33			`pushl @rr14,rr6`
34			`#endif`
35
36			`/* rr2 - length (high word ignored)`
37			`* rr4 - src`
38			`* rr6 - dest`
39			`*/`
40
41			`testl rr2`
42			`jr z,finish`
43
44			`/* check for destructive overlap (src < dest && dest < src + length) */`
45
46			`cpl rr6,rr4`
47			`jp ule,memmove_entry /* non-destructive, let memcpy do the work */`
48			`ldl rr0,rr2`
49			`addl rr0,rr4 /* rr0 = src + length */`
50			`cpl rr0,rr6`
51			`jp ult,memmove_entry /* non-destructive, let memcpy do the work */`
52
53			`/* set-up pointers to copy backwards, add (length - 1) */`
54			`addl rr4,rr2 /* src + length */`
55			`addl rr6,rr2 /* dest + length */`
56			`subl rr4,#1`
57			`subl rr6,#1`
58
59			`/* check alignment */`
60			`bitb rl7,#0 /* odd destination address? */`
61			`jr z,testsrc`
62			`bitb rl5,#0 /* odd source address? */`
63			`jr z,odd_copy`
64			`jr even_copy`
65
66			`testsrc:`
67			`bitb rl5,#0`
68			`jr nz,odd_copy /* src even, dest odd */`
69			`lddb @rr6,@rr4,r3`
70			`jr ov,finish /* jump if r5 is zero now */`
71
72			`/* copy words */`
73			`even_copy:`
74			`ld r2,r3 /* remember length */`
75			`srl r3,#1`
76			`/* jr z,no_words it cannot be zero here */`
77
78			`dec r5,#1`
79			`dec r7,#1`
80			`lddr @rr6,@rr4,r3`
81
82			`no_words:`
83			`bitb rl2,#0 /* odd length? */`
84			`jr z,finish`
85			`inc r5,#1`
86			`inc r7,#1`
87			`lddb @rr6,@rr4,r2 /* yes, copy last byte */`
88			`jr finish`
89
90			`/* copy bytes */`
91			`odd_copy:`
92			`lddrb @rr6,@rr4,r3`
93
94			`finish:`
95			`#ifdef __STD_CALL__`
96			`ldl rr6,rr14(#4)`
97			`#else`
98			`popl rr2,@rr14`
99			`#endif`
100
101
102			`#else /* above Z8001, below Z8002 */`
103
104
105			`unsegm`
106
107			`#ifdef __STD_CALL__`
108			`ld r7,r15(#2)`
109			`ld r6,r15(#4)`
110			`ld r5,r15(#6)`
111			`#else`
112			`ld r2,r7 /* buffer pointer return value */`
113			`#endif`
114
115			`/* r5 - length`
116			`* r6 - src`
117			`* r7 - dest`
118			`*/`
119			`test r5`
120			`jr z,finish`
121
122			`/* check for destructive overlap (src < dest && dest < src + length) */`
123
124			`cp r7,r6`
125			`jp ule,memmove_entry /* non-destructive, let memcpy do the work */`
126			`ld r0,r5`
127			`add r0,r6 /* r0 = src + length */`
128			`cp r0,r7`
129			`jp ult,memmove_entry /* non-destructive, let memcpy do the work */`
130
131			`/* set-up pointers to copy backwards, add (length - 1) */`
132			`add r6,r5 /* src + length */`
133			`add r7,r5 /* dest + length */`
134			`dec r6,#1`
135			`dec r7,#1`
136
137			`/* check alignment */`
138			`bitb rl7,#0 /* odd destination address? */`
139			`jr z,testsrc`
140			`bitb rl6,#0 /* odd source address? */`
141			`jr z,odd_copy`
142			`jr even_copy`
143
144			`testsrc:`
145			`bitb rl6,#0`
146			`jr nz,odd_copy /* src even, dest odd */`
147			`lddb @r7,@r6,r5`
148			`jr ov,finish /* jump if r5 is zero now */`
149
150			`/* copy words */`
151			`even_copy:`
152			`ld r4,r5 /* remember length */`
153			`srl r5,#1`
154			`/* jr z,no_words it cannot be zero here */`
155
156			`dec r6,#1`
157			`dec r7,#1`
158			`lddr @r7,@r6,r5`
159
160			`no_words:`
161			`bitb rl4,#0 /* odd length? */`
162			`jr z,finish`
163			`inc r6,#1`
164			`inc r7,#1`
165			`lddb @r7,@r6,r4 /* yes, copy last byte */`
166			`jr finish`
167
168			`/* copy bytes */`
169			`odd_copy:`
170			`lddrb @r7,@r6,r5`
171
172			`finish:`
173			`#ifdef __STD_CALL__`
174			`ld r7,r15(#2)`
175			`#endif`
176
177			`#endif /* Z8002 */`
178
179			`ret`
180			`.end`

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [newlib-1.17.0/] [newlib/] [libc/] [machine/] [z8k/] [memmove.S] - Blame information for rev 862