1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
|
TEXT memmove(SB), $0
JMP move
TEXT memcpy(SB), $0
move:
MOVW R1, s1+0(FP)
MOVW n+8(FP), R3 /* R3 is count */
MOVW R1, R4 /* R4 is to-pointer */
SGT R0, R3, R5
BEQ R5, ok
MOVW (R0), R0 /* abort if negative count */
ok:
MOVW s2+4(FP), R5 /* R5 is from-pointer */
ADDU R3,R5, R7 /* R7 is end from-pointer */
ADDU R3,R4, R6 /* R6 is end to-pointer */
/*
* easiest test is copy backwards if
* destination string has higher mem address
*/
SGT $4,R3, R2
SGTU R4,R5, R1
BNE R1, back
/*
* if not at least 4 chars,
* don't even mess around.
* 3 chars to guarantee any
* rounding up to a word
* boundary and 4 characters
* to get at least maybe one
* full word store.
*/
BNE R2, fout
/*
* byte at a time to word align destination
*/
f1:
AND $3,R4, R1
BEQ R1, f2
MOVB 0(R5), R8
ADDU $1, R5
MOVB R8, 0(R4)
ADDU $1, R4
JMP f1
/*
* test if source is now word aligned
*/
f2:
AND $3, R5, R1
BNE R1, fun2
/*
* turn R3 into to-end pointer-15
* copy 16 at a time while theres room.
* R6 is smaller than R7 --
* there are problems if R7 is 0.
*/
ADDU $-15,R6, R3
f3:
SGTU R3,R4, R1
BEQ R1, f4
MOVW 0(R5), R8
MOVW 4(R5), R9
MOVW R8, 0(R4)
MOVW 8(R5), R8
MOVW R9, 4(R4)
MOVW 12(R5), R9
ADDU $16, R5
MOVW R8, 8(R4)
MOVW R9, 12(R4)
ADDU $16, R4
JMP f3
/*
* turn R3 into to-end pointer-3
* copy 4 at a time while theres room
*/
f4:
ADDU $-3,R6, R3
f5:
SGTU R3,R4, R1
BEQ R1, fout
MOVW 0(R5), R8
ADDU $4, R5
MOVW R8, 0(R4)
ADDU $4, R4
JMP f5
/*
* forward copy, unaligned
* turn R3 into to-end pointer-15
* copy 16 at a time while theres room.
* R6 is smaller than R7 --
* there are problems if R7 is 0.
*/
fun2:
ADDU $-15,R6, R3
fun3:
SGTU R3,R4, R1
BEQ R1, fun4
MOVWL 0(R5), R8
MOVWR 3(R5), R8
MOVWL 4(R5), R9
MOVWR 7(R5), R9
MOVW R8, 0(R4)
MOVWL 8(R5), R8
MOVWR 11(R5), R8
MOVW R9, 4(R4)
MOVWL 12(R5), R9
MOVWR 15(R5), R9
ADDU $16, R5
MOVW R8, 8(R4)
MOVW R9, 12(R4)
ADDU $16, R4
JMP fun3
/*
* turn R3 into to-end pointer-3
* copy 4 at a time while theres room
*/
fun4:
ADDU $-3,R6, R3
fun5:
SGTU R3,R4, R1
BEQ R1, fout
MOVWL 0(R5), R8
MOVWR 3(R5), R8
ADDU $4, R5
MOVW R8, 0(R4)
ADDU $4, R4
JMP fun5
/*
* last loop, copy byte at a time
*/
fout:
BEQ R7,R5, ret
MOVB 0(R5), R8
ADDU $1, R5
MOVB R8, 0(R4)
ADDU $1, R4
JMP fout
/*
* whole thing repeated for backwards
*/
back:
BNE R2, bout
b1:
AND $3,R6, R1
BEQ R1, b2
MOVB -1(R7), R8
ADDU $-1, R7
MOVB R8, -1(R6)
ADDU $-1, R6
JMP b1
b2:
AND $3, R7, R1
BNE R1, bun2
ADDU $15,R5, R3
b3:
SGTU R7,R3, R1
BEQ R1, b4
MOVW -4(R7), R8
MOVW -8(R7), R9
MOVW R8, -4(R6)
MOVW -12(R7), R8
MOVW R9, -8(R6)
MOVW -16(R7), R9
ADDU $-16, R7
MOVW R8, -12(R6)
MOVW R9, -16(R6)
ADDU $-16, R6
JMP b3
b4:
ADDU $3,R5, R3
b5:
SGTU R7,R3, R1
BEQ R1, bout
MOVW -4(R7), R8
ADDU $-4, R7
MOVW R8, -4(R6)
ADDU $-4, R6
JMP b5
bun2:
ADDU $15,R5, R3
bun3:
SGTU R7,R3, R1
BEQ R1, bun4
MOVWL -4(R7), R8
MOVWR -1(R7), R8
MOVWL -8(R7), R9
MOVWR -5(R7), R9
MOVW R8, -4(R6)
MOVWL -12(R7), R8
MOVWR -9(R7), R8
MOVW R9, -8(R6)
MOVWL -16(R7), R9
MOVWR -13(R7), R9
ADDU $-16, R7
MOVW R8, -12(R6)
MOVW R9, -16(R6)
ADDU $-16, R6
JMP bun3
bun4:
ADDU $3,R5, R3
bun5:
SGTU R7,R3, R1
BEQ R1, bout
MOVWL -4(R7), R8
MOVWR -1(R7), R8
ADDU $-4, R7
MOVW R8, -4(R6)
ADDU $-4, R6
JMP bun5
bout:
BEQ R7,R5, ret
MOVB -1(R7), R8
ADDU $-1, R7
MOVB R8, -1(R6)
ADDU $-1, R6
JMP bout
ret:
MOVW s1+0(FP), R1
RET
END
|
