📄 lib_mem.lst
字号:
199 }
\ 0000003C 017097E2 ADDS R7,R7,#+1
\ 00000040 F7FFFFEA B ??Mem_Set_1
200
201 size_rem = (CPU_SIZE_T)size;
\ ??Mem_Set_2:
\ 00000044 0230B0E1 MOVS R3,R2
202 mem_align_modulo = (CPU_INT08U)((CPU_ADDR)pmem % sizeof(CPU_ALIGN)); /* See Note #3. */
\ 00000048 038010E2 ANDS R8,R0,#0x3 ;; Zero extend
\ 0000004C 0860B0E1 MOVS R6,R8
203
204 pmem_08 = (CPU_INT08U *)pmem;
\ 00000050 0050B0E1 MOVS R5,R0
205 if (mem_align_modulo != 0) { /* If leading octets avail, ... */
\ 00000054 FF6016E2 ANDS R6,R6,#0xFF ;; Zero extend
\ 00000058 000056E3 CMP R6,#+0
\ 0000005C 0A00000A BEQ ??Mem_Set_3
206 i = mem_align_modulo;
\ 00000060 0670B0E1 MOVS R7,R6
207 while ((size_rem > 0) && /* ... start mem buf fill with leading octets ... */
208 (i < sizeof(CPU_ALIGN ))) { /* ... until next CPU_ALIGN word boundary. */
\ ??Mem_Set_4:
\ 00000064 000053E3 CMP R3,#+0
\ 00000068 0700000A BEQ ??Mem_Set_3
\ 0000006C FF7017E2 ANDS R7,R7,#0xFF ;; Zero extend
\ 00000070 040057E3 CMP R7,#+4
\ 00000074 0400002A BCS ??Mem_Set_3
209 *pmem_08++ = data_val;
\ 00000078 0010C5E5 STRB R1,[R5, #+0]
\ 0000007C 015095E2 ADDS R5,R5,#+1
210 size_rem -= sizeof(CPU_INT08U);
\ 00000080 013053E2 SUBS R3,R3,#+1
211 i++;
\ 00000084 017097E2 ADDS R7,R7,#+1
\ 00000088 F5FFFFEA B ??Mem_Set_4
212 }
213 }
214
215 pmem_align = (CPU_ALIGN *)pmem_08; /* See Note #2a. */
\ ??Mem_Set_3:
\ 0000008C 0540B0E1 MOVS R4,R5
216 while (size_rem >= sizeof(CPU_ALIGN)) { /* While mem buf aligned on CPU_ALIGN word boundaries, */
\ ??Mem_Set_5:
\ 00000090 040053E3 CMP R3,#+4
\ 00000094 0300003A BCC ??Mem_Set_6
217 *pmem_align++ = data_align; /* ... fill mem buf with CPU_ALIGN-sized data. */
\ 00000098 00C084E5 STR R12,[R4, #+0]
\ 0000009C 044094E2 ADDS R4,R4,#+4
218 size_rem -= sizeof(CPU_ALIGN);
\ 000000A0 043053E2 SUBS R3,R3,#+4
\ 000000A4 F9FFFFEA B ??Mem_Set_5
219 }
220
221 pmem_08 = (CPU_INT08U *)pmem_align;
\ ??Mem_Set_6:
\ 000000A8 0450B0E1 MOVS R5,R4
222 while (size_rem > 0) { /* Finish mem buf fill with trailing octets. */
\ ??Mem_Set_7:
\ 000000AC 000053E3 CMP R3,#+0
\ 000000B0 0300000A BEQ ??Mem_Set_0
223 *pmem_08++ = data_val;
\ 000000B4 0010C5E5 STRB R1,[R5, #+0]
\ 000000B8 015095E2 ADDS R5,R5,#+1
224 size_rem -= sizeof(CPU_INT08U);
\ 000000BC 013053E2 SUBS R3,R3,#+1
\ 000000C0 F9FFFFEA B ??Mem_Set_7
225 }
\ ??Mem_Set_0:
\ 000000C4 F001BDE8 POP {R4-R8}
\ 000000C8 0EF0A0E1 MOV PC,LR ;; return
226 }
227
228
229 /*$PAGE*/
230 /*
231 *********************************************************************************************************
232 * Mem_Copy()
233 *
234 * Description : Copy data octets from one buffer to another buffer.
235 *
236 * Argument(s) : pdest Pointer to destination memory buffer.
237 *
238 * psrc Pointer to source memory buffer.
239 *
240 * size Number of data buffer octets to copy.
241 *
242 * Return(s) : none.
243 *
244 * Caller(s) : various.
245 *
246 * Note(s) : (1) Null copies allowed (i.e. 0-octet size).
247 *
248 * (2) Memory buffers NOT checked for overlapping.
249 *
250 * (3) For best CPU performance, optimized to fill data buffer using 'CPU_ALIGN'-sized data words.
251 *
252 * (a) Since many word-aligned processors REQUIRE that multi-octet words be accessed on
253 * word-aligned addresses, 'CPU_ALIGN'd words MUST be accessed on 'CPU_ALIGN'd addresses.
254 *
255 * (4) Modulo arithmetic is used to determine whether a memory buffer starts on a 'CPU_ALIGN'
256 * address boundary.
257 *
258 * Modulo arithmetic in ANSI-C REQUIREs operations performed on integer values. Thus,
259 * address values MUST be cast to an appropriately-sized integer value PRIOR to any
260 * mem_align_modulo arithmetic operation.
261 *********************************************************************************************************
262 */
263 /*$PAGE*/
264 #if ((!defined(uC_CFG_OPTIMIZE_ASM_EN)) || \
265 ((defined(uC_CFG_OPTIMIZE_ASM_EN)) && \
266 (uC_CFG_OPTIMIZE_ASM_EN != DEF_ENABLED)))
\ In segment CODE, align 4, keep-with-next
267 void Mem_Copy (void *pdest,
268 void *psrc,
269 CPU_SIZE_T size)
270 {
\ Mem_Copy:
\ 00000000 F00F2DE9 PUSH {R4-R11}
271 CPU_SIZE_T size_rem;
272 CPU_ALIGN *pmem_align_dest;
273 CPU_ALIGN *pmem_align_src;
274 CPU_INT08U *pmem_08_dest;
275 CPU_INT08U *pmem_08_src;
276 CPU_INT08U i;
277 CPU_INT08U mem_align_modulo_dest;
278 CPU_INT08U mem_align_modulo_src;
279 CPU_BOOLEAN mem_aligned;
280
281
282 if (size < 1) { /* See Note #1. */
\ 00000004 000052E3 CMP R2,#+0
\ 00000008 3800000A BEQ ??Mem_Copy_0
283 return;
284 }
285 if (pdest == (void *)0) {
\ 0000000C 000050E3 CMP R0,#+0
\ 00000010 3600000A BEQ ??Mem_Copy_0
286 return;
287 }
288 if (psrc == (void *)0) {
\ 00000014 000051E3 CMP R1,#+0
\ 00000018 3400000A BEQ ??Mem_Copy_0
289 return;
290 }
291
292
293 size_rem = (CPU_SIZE_T )size;
\ 0000001C 0230B0E1 MOVS R3,R2
294
295 pmem_08_dest = (CPU_INT08U *)pdest;
\ 00000020 0050B0E1 MOVS R5,R0
296 pmem_08_src = (CPU_INT08U *)psrc;
\ 00000024 0160B0E1 MOVS R6,R1
297 /* See Note #4. */
298 mem_align_modulo_dest = (CPU_INT08U )((CPU_ADDR)pmem_08_dest % sizeof(CPU_ALIGN));
\ 00000028 03B015E2 ANDS R11,R5,#0x3 ;; Zero extend
\ 0000002C 0B80B0E1 MOVS R8,R11
299 mem_align_modulo_src = (CPU_INT08U )((CPU_ADDR)pmem_08_src % sizeof(CPU_ALIGN));
\ 00000030 03B016E2 ANDS R11,R6,#0x3 ;; Zero extend
\ 00000034 0B90B0E1 MOVS R9,R11
300
301 mem_aligned = (mem_align_modulo_dest == mem_align_modulo_src) ? DEF_YES : DEF_NO;
\ 00000038 FF8018E2 ANDS R8,R8,#0xFF ;; Zero extend
\ 0000003C FF9019E2 ANDS R9,R9,#0xFF ;; Zero extend
\ 00000040 090058E1 CMP R8,R9
\ 00000044 0100001A BNE ??Mem_Copy_1
\ 00000048 01A0A0E3 MOV R10,#+1
\ 0000004C 000000EA B ??Mem_Copy_2
\ ??Mem_Copy_1:
\ 00000050 00A0A0E3 MOV R10,#+0
302
303 if (mem_aligned == DEF_YES) { /* If mem bufs' alignment offset equal, ... */
\ ??Mem_Copy_2:
\ 00000054 FFA01AE2 ANDS R10,R10,#0xFF ;; Zero extend
\ 00000058 01005AE3 CMP R10,#+1
\ 0000005C 1B00001A BNE ??Mem_Copy_3
304 /* ... optimize copy for mem buf alignment. */
305 if (mem_align_modulo_dest != 0) { /* If leading octets avail, ... */
\ 00000060 FF8018E2 ANDS R8,R8,#0xFF ;; Zero extend
\ 00000064 000058E3 CMP R8,#+0
\ 00000068 0C00000A BEQ ??Mem_Copy_4
306 i = mem_align_modulo_dest;
\ 0000006C 0870B0E1 MOVS R7,R8
307 while ((size_rem > 0) && /* ... start mem buf copy with leading octets ... */
308 (i < sizeof(CPU_ALIGN ))) { /* ... until next CPU_ALIGN word boundary. */
\ ??Mem_Copy_5:
\ 00000070 000053E3 CMP R3,#+0
\ 00000074 0900000A BEQ ??Mem_Copy_4
\ 00000078 FF7017E2 ANDS R7,R7,#0xFF ;; Zero extend
\ 0000007C 040057E3 CMP R7,#+4
\ 00000080 0600002A BCS ??Mem_Copy_4
309 *pmem_08_dest++ = *pmem_08_src++;
\ 00000084 00B0D6E5 LDRB R11,[R6, #+0]
\ 00000088 00B0C5E5 STRB R11,[R5, #+0]
\ 0000008C 016096E2 ADDS R6,R6,#+1
\ 00000090 015095E2 ADDS R5,R5,#+1
310 size_rem -= sizeof(CPU_INT08U);
\ 00000094 013053E2 SUBS R3,R3,#+1
311 i++;
\ 00000098 017097E2 ADDS R7,R7,#+1
\ 0000009C F3FFFFEA B ??Mem_Copy_5
312 }
313 }
314
315 pmem_align_dest = (CPU_ALIGN *)pmem_08_dest; /* See Note #3a. */
\ ??Mem_Copy_4:
\ 000000A0 05C0B0E1 MOVS R12,R5
316 pmem_align_src = (CPU_ALIGN *)pmem_08_src;
\ 000000A4 0640B0E1 MOVS R4,R6
317 while (size_rem >= sizeof(CPU_ALIGN)) { /* While mem bufs aligned on CPU_ALIGN word boundaries, */
\ ??Mem_Copy_6:
\ 000000A8 040053E3 CMP R3,#+4
\ 000000AC 0500003A BCC ??Mem_Copy_7
318 *pmem_align_dest++ = *pmem_align_src++; /* ... copy psrc to pdest with CPU_ALIGN-sized words. */
\ 000000B0 00B094E5 LDR R11,[R4, #+0]
\ 000000B4 00B08CE5 STR R11,[R12, #+0]
\ 000000B8 044094E2 ADDS R4,R4,#+4
\ 000000BC 04C09CE2 ADDS R12,R12,#+4
319 size_rem -= sizeof(CPU_ALIGN);
\ 000000C0 043053E2 SUBS R3,R3,#+4
\ 000000C4 F7FFFFEA B ??Mem_Copy_6
320 }
321
322 pmem_08_dest = (CPU_INT08U *)pmem_align_dest;
\ ??Mem_Copy_7:
\ 000000C8 0C50B0E1 MOVS R5,R12
323 pmem_08_src = (CPU_INT08U *)pmem_align_src;
\ 000000CC 0460B0E1 MOVS R6,R4
324 }
325
326 while (size_rem > 0) { /* For unaligned mem bufs or trailing octets, ... */
\ ??Mem_Copy_3:
\ 000000D0 000053E3 CMP R3,#+0
\ 000000D4 0500000A BEQ ??Mem_Copy_0
327 *pmem_08_dest++ = *pmem_08_src++; /* ... copy psrc to pdest by octets. */
\ 000000D8 00B0D6E5 LDRB R11,[R6, #+0]
\ 000000DC 00B0C5E5 STRB R11,[R5, #+0]
\ 000000E0 016096E2 ADDS R6,R6,#+1
\ 000000E4 015095E2 ADDS R5,R5,#+1
328 size_rem -= sizeof(CPU_INT08U);
\ 000000E8 013053E2 SUBS R3,R3,#+1
\ 000000EC F7FFFFEA B ??Mem_Copy_3
329 }
\ ??Mem_Copy_0:
\ 000000F0 F00FBDE8 POP {R4-R11}
\ 000000F4 0EF0A0E1 MOV PC,LR ;; return
330 }
331 #endif
332
333
334 /*$PAGE*/
335 /*
336 *********************************************************************************************************
337 * Mem_Cmp()
338 *
339 * Description : Verify that ALL data octets in two memory buffers are identical in sequence.
340 *
341 * Argument(s) : p1_mem Pointer to first memory buffer.
342 *
343 * p2_mem Pointer to second memory buffer.
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -