📄 osal_memory.lst
字号:
\ ??theHeap:
\ 000000 DS 2
\ 000002 REQUIRE `?<Initializer for theHeap>`
\ 000002 REQUIRE __INIT_XDATA_I
154 #endif
155
156 /*********************************************************************
157 * LOCAL FUNCTIONS
158 */
159
160 /*********************************************************************
161 * @fn osal_mem_init
162 *
163 * @brief Initialize the heap memory management system.
164 *
165 * @param void
166 *
167 * @return void
168 */
\ In segment BANKED_CODE, align 1, keep-with-next
169 void osal_mem_init( void )
\ osal_mem_init:
170 {
\ 000000 C082 PUSH DPL
\ 000002 C083 PUSH DPH
\ 000004 ; Saved register size: 2
\ 000004 ; Auto size: 0
171 osalMemHdr_t *tmp;
172
173 #if ( OSALMEM_PROFILER )
174 osal_memset( theHeap, OSALMEM_INIT, MAXMEMHEAP );
175 #endif
176
177 // Setup a NULL block at the end of the heap for fast comparisons with zero.
178 tmp = (osalMemHdr_t *)theHeap + (MAXMEMHEAP / HDRSZ) - 1;
179 *tmp = 0;
\ 000004 90.... MOV DPTR,#??theHeap
\ 000007 E0 MOVX A,@DPTR
\ 000008 24FE ADD A,#-0x2
\ 00000A F8 MOV R0,A
\ 00000B A3 INC DPTR
\ 00000C E0 MOVX A,@DPTR
\ 00000D 340F ADDC A,#0xf
\ 00000F F9 MOV R1,A
\ 000010 8882 MOV DPL,R0
\ 000012 8983 MOV DPH,R1
\ 000014 E4 CLR A
\ 000015 F0 MOVX @DPTR,A
\ 000016 A3 INC DPTR
\ 000017 F0 MOVX @DPTR,A
180
181 // Setup a small-block bucket.
182 tmp = (osalMemHdr_t *)theHeap;
183 *tmp = SMALLBLKHEAP;
\ 000018 90.... MOV DPTR,#??theHeap
\ 00001B E0 MOVX A,@DPTR
\ 00001C F8 MOV R0,A
\ 00001D A3 INC DPTR
\ 00001E E0 MOVX A,@DPTR
\ 00001F F583 MOV DPH,A
\ 000021 8882 MOV DPL,R0
\ 000023 74E8 MOV A,#-0x18
\ 000025 F0 MOVX @DPTR,A
\ 000026 A3 INC DPTR
\ 000027 E4 CLR A
\ 000028 F0 MOVX @DPTR,A
184
185 // Setup the wilderness.
186 tmp = (osalMemHdr_t *)theHeap + (SMALLBLKHEAP / HDRSZ);
\ 000029 90.... MOV DPTR,#??theHeap
\ 00002C E0 MOVX A,@DPTR
\ 00002D 24E8 ADD A,#-0x18
\ 00002F F8 MOV R0,A
\ 000030 A3 INC DPTR
\ 000031 E0 MOVX A,@DPTR
\ 000032 3400 ADDC A,#0x0
\ 000034 F9 MOV R1,A
187 *tmp = ((MAXMEMHEAP / HDRSZ) * HDRSZ) - SMALLBLKHEAP - HDRSZ;
\ 000035 8882 MOV DPL,R0
\ 000037 8983 MOV DPH,R1
\ 000039 7416 MOV A,#0x16
\ 00003B F0 MOVX @DPTR,A
\ 00003C A3 INC DPTR
\ 00003D 740F MOV A,#0xf
\ 00003F F0 MOVX @DPTR,A
188
189 #if ( OSALMEM_GUARD )
190 ready = OSALMEM_READY;
\ 000040 74E2 MOV A,#-0x1e
\ 000042 90.... MOV DPTR,#??ready
\ 000045 F0 MOVX @DPTR,A
191 #endif
192
193 // Setup a NULL block that is never freed so that the small-block bucket
194 // is never coalesced with the wilderness.
195 ff1 = tmp;
\ 000046 90.... MOV DPTR,#??ff1
\ 000049 E8 MOV A,R0
\ 00004A F0 MOVX @DPTR,A
\ 00004B A3 INC DPTR
\ 00004C E9 MOV A,R1
\ 00004D F0 MOVX @DPTR,A
196 ff2 = osal_mem_alloc( 0 );
\ 00004E ; Setup parameters for call to function osal_mem_alloc
\ 00004E 7A00 MOV R2,#0x0
\ 000050 7B00 MOV R3,#0x0
\ 000052 90.... MOV DPTR,#(osal_mem_alloc & 0xffff)
\ 000055 74.. MOV A,#((osal_mem_alloc >> 16) & 0xff)
\ 000057 12.... LCALL ?BCALL ; Banked call to: DPTR()
\ 00005A 90.... MOV DPTR,#??ff2
\ 00005D EA MOV A,R2
\ 00005E F0 MOVX @DPTR,A
\ 00005F A3 INC DPTR
\ 000060 EB MOV A,R3
\ 000061 F0 MOVX @DPTR,A
197 ff1 = (osalMemHdr_t *)theHeap;
\ 000062 90.... MOV DPTR,#??theHeap
\ 000065 12.... LCALL ?Subroutine0 & 0xFFFF
198
199 #if ( OSALMEM_METRICS )
200 /* Start with the small-block bucket and the wilderness - don't count the
201 * end-of-heap NULL block nor the end-of-small-block NULL block.
202 */
203 blkCnt = blkFree = 2;
204 #endif
205 }
\ ??CrossCallReturnLabel_0:
\ 000068 REQUIRE ?Subroutine2
\ 000068 ; // Fall through to label ?Subroutine2
\ In segment BANKED_CODE, align 1, keep-with-next
\ ?Subroutine2:
\ 000000 D083 POP DPH
\ 000002 D082 POP DPL
\ 000004 02.... LJMP ?BRET
\ In segment BANKED_CODE, align 1, keep-with-next
\ ?Subroutine0:
\ 000000 12.... LCALL ??Subroutine1_0 & 0xFFFF
\ ??CrossCallReturnLabel_5:
\ 000003 90.... MOV DPTR,#??ff1
\ 000006 E8 MOV A,R0
\ 000007 F0 MOVX @DPTR,A
\ 000008 A3 INC DPTR
\ 000009 E9 MOV A,R1
\ 00000A F0 MOVX @DPTR,A
\ 00000B 22 RET
\ In segment BANKED_CODE, align 1, keep-with-next
\ ?Subroutine1:
\ 000000 FB MOV R3,A
\ 000001 8A82 MOV DPL,R2
\ 000003 8B83 MOV DPH,R3
\ ??Subroutine1_0:
\ 000005 E0 MOVX A,@DPTR
\ 000006 F8 MOV R0,A
\ 000007 A3 INC DPTR
\ 000008 E0 MOVX A,@DPTR
\ 000009 F9 MOV R1,A
\ 00000A 22 RET
206
207 /*********************************************************************
208 * @fn osal_mem_kick
209 *
210 * @brief Kick the ff1 pointer out past the long-lived OSAL Task blocks.
211 * Invoke this once after all long-lived blocks have been allocated -
212 * presently at the end of osal_init_system().
213 *
214 * @param void
215 *
216 * @return void
217 */
\ In segment BANKED_CODE, align 1, keep-with-next
218 void osal_mem_kick( void )
\ osal_mem_kick:
219 {
\ 000000 C082 PUSH DPL
\ 000002 C083 PUSH DPH
\ 000004 ; Saved register size: 2
\ 000004 ; Auto size: 0
220 halIntState_t intState;
221
222 HAL_ENTER_CRITICAL_SECTION( intState ); // Hold off interrupts.
\ 000004 A2AF MOV C,0xa8.7
\ 000006 E4 CLR A
\ 000007 92E0 MOV 0xE0 /* A */.0,C
\ 000009 C2AF CLR 0xa8.7
223
224 /* Logic in osal_mem_free() will ratchet ff1 back down to the first free
225 * block in the small-block bucket.
226 */
227 ff1 = ff2;
\ 00000B 90.... MOV DPTR,#??ff2
\ 00000E 12.... LCALL ?Subroutine0 & 0xFFFF
228
229 HAL_EXIT_CRITICAL_SECTION( intState ); // Re-enable interrupts.
\ ??CrossCallReturnLabel_1:
\ 000011 92AF MOV 0xa8.7,C
230 }
\ 000013 80.. SJMP ?Subroutine2
231
232 /*********************************************************************
233 * @fn osal_mem_alloc
234 *
235 * @brief Implementation of the allocator functionality.
236 *
237 * @param size - number of bytes to allocate from the heap.
238 *
239 * @return void * - pointer to the heap allocation; NULL if error or failure.
240 */
\ In segment BANKED_CODE, align 1, keep-with-next
241 void *osal_mem_alloc( uint16 size )
\ osal_mem_alloc:
242 {
\ 000000 74F2 MOV A,#-0xe
\ 000002 12.... LCALL ?BANKED_ENTER_XDATA
\ 000005 ; Saved register size: 14
\ 000005 ; Auto size: 0
\ 000005 8A.. MOV ?V0 + 0,R2
\ 000007 8B.. MOV ?V0 + 1,R3
243 osalMemHdr_t *prev;
244 osalMemHdr_t *hdr;
245 halIntState_t intState;
246 uint16 tmp;
247 byte coal = 0;
\ 000009 75..00 MOV ?V0 + 2,#0x0
248
249 #if ( OSALMEM_GUARD )
250 // Try to protect against premature use by HAL / OSAL.
251 if ( ready != OSALMEM_READY )
\ 00000C 90.... MOV DPTR,#??ready
\ 00000F E0 MOVX A,@DPTR
\ 000010 64E2 XRL A,#0xe2
\ 000012 6008 JZ ??osal_mem_alloc_0
252 {
253 osal_mem_init();
\ 000014 ; Setup parameters for call to function osal_mem_init
\ 000014 90.... MOV DPTR,#(osal_mem_init & 0xffff)
\ 000017 74.. MOV A,#((osal_mem_init >> 16) & 0xff)
\ 000019 12.... LCALL ?BCALL ; Banked call to: DPTR()
254 }
255 #endif
256
257 OSALMEM_ASSERT( size );
258
259 size += HDRSZ;
\ ??osal_mem_alloc_0:
\ 00001C E5.. MOV A,?V0 + 0
\ 00001E 2402 ADD A,#0x2
\ 000020 F5.. MOV ?V0 + 0,A
\ 000022 E5.. MOV A,?V0 + 1
\ 000024 3400 ADDC A,#0x0
\ 000026 F5.. MOV ?V0 + 1,A
260
261 // Calculate required bytes to add to 'size' to align to halDataAlign_t.
262 if ( sizeof( halDataAlign_t ) == 2 )
263 {
264 size += (size & 0x01);
265 }
266 else if ( sizeof( halDataAlign_t ) != 1 )
267 {
268 const byte mod = size % sizeof( halDataAlign_t );
269
270 if ( mod != 0 )
271 {
272 size += (sizeof( halDataAlign_t ) - mod);
273 }
274 }
275
276 HAL_ENTER_CRITICAL_SECTION( intState ); // Hold off interrupts.
\ 000028 A2AF MOV C,0xa8.7
\ 00002A E4 CLR A
\ 00002B 92E0 MOV 0xE0 /* A */.0,C
\ 00002D FC MOV R4,A
\ 00002E C2AF CLR 0xa8.7
277
278 // Smaller allocations are first attempted in the small-block bucket.
279 if ( size <= OSALMEM_SMALL_BLKSZ )
\ 000030 C3 CLR C
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -