📄 lib_mem.lst
字号:
139 }
\ 0000001C 3080BDE8 POP {R4,R5,PC} ;; return
140
141
142 /*$PAGE*/
143 /*
144 *********************************************************************************************************
145 * Mem_Set()
146 *
147 * Description : Fill data buffer with specified data octet.
148 *
149 * Argument(s) : pmem Pointer to memory buffer to fill with specified data octet.
150 *
151 * data_val Data fill octet value.
152 *
153 * size Number of data buffer octets to fill.
154 *
155 * Return(s) : none.
156 *
157 * Caller(s) : various.
158 *
159 * Note(s) : (1) Null sets allowed (i.e. 0-octet size).
160 *
161 * (2) For best CPU performance, optimized to fill data buffer using 'CPU_ALIGN'-sized data words.
162 *
163 * (a) Since many word-aligned processors REQUIRE that multi-octet words be accessed on
164 * word-aligned addresses, 'CPU_ALIGN'd words MUST be accessed on 'CPU_ALIGN'd addresses.
165 *
166 * (3) Modulo arithmetic is used to determine whether a memory buffer starts on a 'CPU_ALIGN'
167 * address boundary.
168 *
169 * Modulo arithmetic in ANSI-C REQUIREs operations performed on integer values. Thus,
170 * address values MUST be cast to an appropriately-sized integer value PRIOR to any
171 * mem_align_modulo arithmetic operation.
172 *********************************************************************************************************
173 */
174
\ In segment CODE, align 4, keep-with-next
175 void Mem_Set (void *pmem,
176 CPU_INT08U data_val,
177 CPU_SIZE_T size)
178 {
\ Mem_Set:
\ 00000000 F0012DE9 PUSH {R4-R8}
179 CPU_SIZE_T size_rem;
180 CPU_ALIGN data_align;
181 CPU_ALIGN *pmem_align;
182 CPU_INT08U *pmem_08;
183 CPU_INT08U mem_align_modulo;
184 CPU_INT08U i;
185
186
187 if (size < 1) { /* See Note #1. */
\ 00000004 000052E3 CMP R2,#+0
\ 00000008 2D00000A BEQ ??Mem_Set_0
188 return;
189 }
190 if (pmem == (void *)0) {
\ 0000000C 000050E3 CMP R0,#+0
\ 00000010 2B00000A BEQ ??Mem_Set_0
191 return;
192 }
193
194
195 data_align = 0;
\ 00000014 0080A0E3 MOV R8,#+0
\ 00000018 08C0B0E1 MOVS R12,R8
196 for (i = 0; i < sizeof(CPU_ALIGN); i++) { /* Fill each data_align octet with data val. */
\ 0000001C 0080A0E3 MOV R8,#+0
\ 00000020 0870B0E1 MOVS R7,R8
\ ??Mem_Set_1:
\ 00000024 FF7017E2 ANDS R7,R7,#0xFF ;; Zero extend
\ 00000028 040057E3 CMP R7,#+4
\ 0000002C 0400002A BCS ??Mem_Set_2
197 data_align <<= DEF_OCTET_NBR_BITS;
\ 00000030 0CC4B0E1 LSLS R12,R12,#+8
198 data_align |= (CPU_ALIGN)data_val;
\ 00000034 0180B0E1 MOVS R8,R1
\ 00000038 0CC098E1 ORRS R12,R8,R12
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;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -