📄 lib_mem.lst
字号:
\ 00000004 23D0 BEQ.N ??Mem_Set_0
189 return;
190 }
191 if (pmem == (void *)0) {
\ 00000006 0028 CMP R0,#+0
\ 00000008 21D0 BEQ.N ??Mem_Set_0
192 return;
193 }
194
195
196 data_align = 0;
\ 0000000A 0023 MOVS R3,#+0
197 for (i = 0; i < sizeof(CPU_ALIGN); i++) { /* Fill each data_align octet with data val. */
\ 0000000C 1C00 MOVS R4,R3
\ 0000000E 02E0 B.N ??Mem_Set_1
198 data_align <<= DEF_OCTET_NBR_BITS;
199 data_align |= (CPU_ALIGN)data_val;
\ ??Mem_Set_2:
\ 00000010 51EA0323 ORRS R3,R1,R3, LSL #+8
200 }
\ 00000014 641C ADDS R4,R4,#+1
\ ??Mem_Set_1:
\ 00000016 042C CMP R4,#+4
\ 00000018 FAD3 BCC.N ??Mem_Set_2
201
202 size_rem = (CPU_SIZE_T)size;
203 mem_align_modulo = (CPU_INT08U)((CPU_ADDR)pmem % sizeof(CPU_ALIGN)); /* See Note #3. */
\ 0000001A 0400 MOVS R4,R0
\ 0000001C A407 LSLS R4,R4,#+30
\ 0000001E A40F LSRS R4,R4,#+30
204
205 pmem_08 = (CPU_INT08U *)pmem;
206 if (mem_align_modulo != 0) { /* If leading octets avail, ... */
\ 00000020 0DD0 BEQ.N ??Mem_Set_3
207 i = mem_align_modulo;
\ 00000022 04E0 B.N ??Mem_Set_4
208 while ((size_rem > 0) && /* ... start mem buf fill with leading octets ... */
209 (i < sizeof(CPU_ALIGN ))) { /* ... until next CPU_ALIGN word boundary. */
210 *pmem_08++ = data_val;
\ ??Mem_Set_5:
\ 00000024 0170 STRB R1,[R0, #+0]
\ 00000026 401C ADDS R0,R0,#+1
211 size_rem -= sizeof(CPU_INT08U);
\ 00000028 521E SUBS R2,R2,#+1
212 i++;
\ 0000002A 641C ADDS R4,R4,#+1
\ 0000002C E4B2 UXTB R4,R4
213 }
\ ??Mem_Set_4:
\ 0000002E 002A CMP R2,#+0
\ 00000030 05D0 BEQ.N ??Mem_Set_3
\ 00000032 042C CMP R4,#+4
\ 00000034 F6D3 BCC.N ??Mem_Set_5
214 }
215
216 pmem_align = (CPU_ALIGN *)pmem_08; /* See Note #2a. */
\ 00000036 02E0 B.N ??Mem_Set_3
217 while (size_rem >= sizeof(CPU_ALIGN)) { /* While mem buf aligned on CPU_ALIGN word boundaries, */
218 *pmem_align++ = data_align; /* ... fill mem buf with CPU_ALIGN-sized data. */
\ ??Mem_Set_6:
\ 00000038 0360 STR R3,[R0, #+0]
\ 0000003A 001D ADDS R0,R0,#+4
219 size_rem -= sizeof(CPU_ALIGN);
\ 0000003C 121F SUBS R2,R2,#+4
220 }
\ ??Mem_Set_3:
\ 0000003E 042A CMP R2,#+4
\ 00000040 FAD2 BCS.N ??Mem_Set_6
221
222 pmem_08 = (CPU_INT08U *)pmem_align;
\ 00000042 002A CMP R2,#+0
\ 00000044 02E0 B.N ??Mem_Set_7
223 while (size_rem > 0) { /* Finish mem buf fill with trailing octets. */
224 *pmem_08++ = data_val;
\ ??Mem_Set_8:
\ 00000046 0170 STRB R1,[R0, #+0]
\ 00000048 401C ADDS R0,R0,#+1
225 size_rem -= sizeof(CPU_INT08U);
\ 0000004A 521E SUBS R2,R2,#+1
226 }
\ ??Mem_Set_7:
\ 0000004C FBD1 BNE.N ??Mem_Set_8
\ ??Mem_Set_0:
\ 0000004E 30BD POP {R4,R5,PC} ;; return
227 }
228
229
230 /*$PAGE*/
231 /*
232 *********************************************************************************************************
233 * Mem_Copy()
234 *
235 * Description : Copy data octets from one buffer to another buffer.
236 *
237 * Argument(s) : pdest Pointer to destination memory buffer.
238 *
239 * psrc Pointer to source memory buffer.
240 *
241 * size Number of data buffer octets to copy.
242 *
243 * Return(s) : none.
244 *
245 * Caller(s) : various.
246 *
247 * Note(s) : (1) Null copies allowed (i.e. 0-octet size).
248 *
249 * (2) Memory buffers NOT checked for overlapping.
250 *
251 * (3) For best CPU performance, optimized to fill data buffer using 'CPU_ALIGN'-sized data words.
252 *
253 * (a) Since many word-aligned processors REQUIRE that multi-octet words be accessed on
254 * word-aligned addresses, 'CPU_ALIGN'd words MUST be accessed on 'CPU_ALIGN'd addresses.
255 *
256 * (4) Modulo arithmetic is used to determine whether a memory buffer starts on a 'CPU_ALIGN'
257 * address boundary.
258 *
259 * Modulo arithmetic in ANSI-C REQUIREs operations performed on integer values. Thus,
260 * address values MUST be cast to an appropriately-sized integer value PRIOR to any
261 * mem_align_modulo arithmetic operation.
262 *********************************************************************************************************
263 */
264 /*$PAGE*/
265 #if ((!defined(uC_CFG_OPTIMIZE_ASM_EN)) || \
266 ((defined(uC_CFG_OPTIMIZE_ASM_EN)) && \
267 (uC_CFG_OPTIMIZE_ASM_EN != DEF_ENABLED)))
\ In segment CODE, align 4, keep-with-next
268 void Mem_Copy (void *pdest,
269 void *psrc,
270 CPU_SIZE_T size)
271 {
\ Mem_Copy:
\ 00000000 30B5 PUSH {R4,R5,LR}
272 CPU_SIZE_T size_rem;
273 CPU_ALIGN *pmem_align_dest;
274 CPU_ALIGN *pmem_align_src;
275 CPU_INT08U *pmem_08_dest;
276 CPU_INT08U *pmem_08_src;
277 CPU_INT08U i;
278 CPU_INT08U mem_align_modulo_dest;
279 CPU_INT08U mem_align_modulo_src;
280 CPU_BOOLEAN mem_aligned;
281
282
283 if (size < 1) { /* See Note #1. */
\ 00000002 002A CMP R2,#+0
\ 00000004 2FD0 BEQ.N ??Mem_Copy_0
284 return;
285 }
286 if (pdest == (void *)0) {
\ 00000006 0028 CMP R0,#+0
\ 00000008 2DD0 BEQ.N ??Mem_Copy_0
287 return;
288 }
289 if (psrc == (void *)0) {
\ 0000000A 0029 CMP R1,#+0
\ 0000000C 2BD0 BEQ.N ??Mem_Copy_0
290 return;
291 }
292
293
294 size_rem = (CPU_SIZE_T )size;
295
296 pmem_08_dest = (CPU_INT08U *)pdest;
297 pmem_08_src = (CPU_INT08U *)psrc;
298 /* See Note #4. */
299 mem_align_modulo_dest = (CPU_INT08U )((CPU_ADDR)pmem_08_dest % sizeof(CPU_ALIGN));
\ 0000000E 0300 MOVS R3,R0
\ 00000010 9B07 LSLS R3,R3,#+30
\ 00000012 9B0F LSRS R3,R3,#+30
300 mem_align_modulo_src = (CPU_INT08U )((CPU_ADDR)pmem_08_src % sizeof(CPU_ALIGN));
301
302 mem_aligned = (mem_align_modulo_dest == mem_align_modulo_src) ? DEF_YES : DEF_NO;
\ 00000014 1C00 MOVS R4,R3
\ 00000016 0D00 MOVS R5,R1
\ 00000018 AD07 LSLS R5,R5,#+30
\ 0000001A AD0F LSRS R5,R5,#+30
\ 0000001C AC42 CMP R4,R5
\ 0000001E 01D1 BNE.N ??Mem_Copy_1
\ 00000020 0124 MOVS R4,#+1
\ 00000022 00E0 B.N ??Mem_Copy_2
\ ??Mem_Copy_1:
\ 00000024 0024 MOVS R4,#+0
303
304 if (mem_aligned == DEF_YES) { /* If mem bufs' alignment offset equal, ... */
\ ??Mem_Copy_2:
\ 00000026 012C CMP R4,#+1
\ 00000028 1BD1 BNE.N ??Mem_Copy_3
305 /* ... optimize copy for mem buf alignment. */
306 if (mem_align_modulo_dest != 0) { /* If leading octets avail, ... */
\ 0000002A 1C00 MOVS R4,R3
\ 0000002C 11D0 BEQ.N ??Mem_Copy_4
307 i = mem_align_modulo_dest;
\ 0000002E 06E0 B.N ??Mem_Copy_5
308 while ((size_rem > 0) && /* ... start mem buf copy with leading octets ... */
309 (i < sizeof(CPU_ALIGN ))) { /* ... until next CPU_ALIGN word boundary. */
310 *pmem_08_dest++ = *pmem_08_src++;
\ ??Mem_Copy_6:
\ 00000030 0C78 LDRB R4,[R1, #+0]
\ 00000032 0470 STRB R4,[R0, #+0]
\ 00000034 491C ADDS R1,R1,#+1
\ 00000036 401C ADDS R0,R0,#+1
311 size_rem -= sizeof(CPU_INT08U);
\ 00000038 521E SUBS R2,R2,#+1
312 i++;
\ 0000003A 5B1C ADDS R3,R3,#+1
\ 0000003C DBB2 UXTB R3,R3
313 }
\ ??Mem_Copy_5:
\ 0000003E 002A CMP R2,#+0
\ 00000040 07D0 BEQ.N ??Mem_Copy_4
\ 00000042 042B CMP R3,#+4
\ 00000044 F4D3 BCC.N ??Mem_Copy_6
314 }
315
316 pmem_align_dest = (CPU_ALIGN *)pmem_08_dest; /* See Note #3a. */
317 pmem_align_src = (CPU_ALIGN *)pmem_08_src;
\ 00000046 04E0 B.N ??Mem_Copy_4
318 while (size_rem >= sizeof(CPU_ALIGN)) { /* While mem bufs aligned on CPU_ALIGN word boundaries, */
319 *pmem_align_dest++ = *pmem_align_src++; /* ... copy psrc to pdest with CPU_ALIGN-sized words. */
\ ??Mem_Copy_7:
\ 00000048 0B68 LDR R3,[R1, #+0]
\ 0000004A 0360 STR R3,[R0, #+0]
\ 0000004C 091D ADDS R1,R1,#+4
\ 0000004E 001D ADDS R0,R0,#+4
320 size_rem -= sizeof(CPU_ALIGN);
\ 00000050 121F SUBS R2,R2,#+4
321 }
\ ??Mem_Copy_4:
\ 00000052 042A CMP R2,#+4
\ 00000054 F8D2 BCS.N ??Mem_Copy_7
322
323 pmem_08_dest = (CPU_INT08U *)pmem_align_dest;
324 pmem_08_src = (CPU_INT08U *)pmem_align_src;
\ 00000056 04E0 B.N ??Mem_Copy_3
325 }
326
327 while (size_rem > 0) { /* For unaligned mem bufs or trailing octets, ... */
328 *pmem_08_dest++ = *pmem_08_src++; /* ... copy psrc to pdest by octets. */
\ ??Mem_Copy_8:
\ 00000058 0B78 LDRB R3,[R1, #+0]
\ 0000005A 0370 STRB R3,[R0, #+0]
\ 0000005C 491C ADDS R1,R1,#+1
\ 0000005E 401C ADDS R0,R0,#+1
329 size_rem -= sizeof(CPU_INT08U);
\ 00000060 521E SUBS R2,R2,#+1
330 }
\ ??Mem_Copy_3:
\ 00000062 002A CMP R2,#+0
\ 00000064 F8D1 BNE.N ??Mem_Copy_8
\ ??Mem_Copy_0:
\ 00000066 30BD POP {R4,R5,PC} ;; return
331 }
332 #endif
333
334
335 /*$PAGE*/
336 /*
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -