jmemmgr.txt
来自「STM32F103ZET6+UCOSII+UCGUI源码」· 文本 代码 · 共 1,415 行 · 第 1/5 页
TXT
1,415 行
;;;736 ptr->dirty = FALSE;
000060 2000 MOVS r0,#0
000062 6260 STR r0,[r4,#0x24]
|L2.100|
;;;737 }
;;;738 /* Decide what part of virtual array to access.
;;;739 * Algorithm: if target address > current window, assume forward scan,
;;;740 * load starting at target address. If target address < current window,
;;;741 * assume backward scan, load so that target area is top of window.
;;;742 * Note that when switching from forward write to forward read, will have
;;;743 * start_row = 0, so the limiting case applies and we load from 0 anyway.
;;;744 */
;;;745 if (start_row > ptr->cur_start_row) {
000064 69a0 LDR r0,[r4,#0x18]
000066 42b0 CMP r0,r6
000068 d201 BCS |L2.110|
;;;746 ptr->cur_start_row = start_row;
00006a 61a6 STR r6,[r4,#0x18]
00006c e004 B |L2.120|
|L2.110|
;;;747 } else {
;;;748 /* use long arithmetic here to avoid overflow & unsigned problems */
;;;749 long ltemp;
;;;750
;;;751 ltemp = (long) end_row - (long) ptr->rows_in_mem;
00006e 6920 LDR r0,[r4,#0x10]
000070 1a38 SUBS r0,r7,r0
;;;752 if (ltemp < 0)
000072 d500 BPL |L2.118|
;;;753 ltemp = 0; /* don't fall off front end of file */
000074 2000 MOVS r0,#0
|L2.118|
;;;754 ptr->cur_start_row = (JDIMENSION) ltemp;
000076 61a0 STR r0,[r4,#0x18]
|L2.120|
;;;755 }
;;;756 /* Read in the selected part of the array.
;;;757 * During the initial write pass, we will do no actual read
;;;758 * because the selected part is all undefined.
;;;759 */
;;;760 do_sarray_io(cinfo, ptr, FALSE);
000078 2200 MOVS r2,#0
00007a 4621 MOV r1,r4
00007c 4628 MOV r0,r5
00007e f7fffffe BL do_sarray_io
|L2.130|
;;;761 }
;;;762 /* Ensure the accessed part of the array is defined; prezero if needed.
;;;763 * To improve locality of access, we only prezero the part of the array
;;;764 * that the caller is about to access, not the entire in-memory array.
;;;765 */
;;;766 if (ptr->first_undef_row < end_row) {
000082 69e0 LDR r0,[r4,#0x1c]
000084 42b8 CMP r0,r7
000086 d221 BCS |L2.204|
;;;767 if (ptr->first_undef_row < start_row) {
000088 42b0 CMP r0,r6
00008a d20a BCS |L2.162|
;;;768 if (writable) /* writer skipped over a section of array */
00008c f1b80f00 CMP r8,#0
000090 d006 BEQ |L2.160|
;;;769 ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
000092 6829 LDR r1,[r5,#0]
000094 f8c19014 STR r9,[r1,#0x14]
000098 6828 LDR r0,[r5,#0]
00009a 6801 LDR r1,[r0,#0]
00009c 4628 MOV r0,r5
00009e 4788 BLX r1
|L2.160|
;;;770 undef_row = start_row; /* but reader is allowed to read ahead */
0000a0 4630 MOV r0,r6
|L2.162|
;;;771 } else {
;;;772 undef_row = ptr->first_undef_row;
;;;773 }
;;;774 if (writable)
0000a2 f1b80f00 CMP r8,#0
0000a6 d000 BEQ |L2.170|
;;;775 ptr->first_undef_row = end_row;
0000a8 61e7 STR r7,[r4,#0x1c]
|L2.170|
;;;776 if (ptr->pre_zero) {
0000aa 6a21 LDR r1,[r4,#0x20]
0000ac b1d1 CBZ r1,|L2.228|
;;;777 size_t bytesperrow = (size_t) ptr->samplesperrow * SIZEOF(JSAMPLE);
;;;778 undef_row -= ptr->cur_start_row; /* make indexes relative to buffer */
;;;779 end_row -= ptr->cur_start_row;
0000ae 69a1 LDR r1,[r4,#0x18]
;;;780 while (undef_row < end_row) {
0000b0 f8d49008 LDR r9,[r4,#8]
0000b4 1a7f SUBS r7,r7,r1 ;779
0000b6 1a45 SUBS r5,r0,r1 ;778
0000b8 e006 B |L2.200|
|L2.186|
;;;781 jzero_far((void FAR *) ptr->mem_buffer[undef_row], bytesperrow);
0000ba 6820 LDR r0,[r4,#0]
0000bc 4649 MOV r1,r9
0000be f8500025 LDR r0,[r0,r5,LSL #2]
0000c2 f7fffffe BL jzero_far
;;;782 undef_row++;
0000c6 1c6d ADDS r5,r5,#1
|L2.200|
0000c8 42bd CMP r5,r7 ;780
0000ca d3f6 BCC |L2.186|
|L2.204|
;;;783 }
;;;784 } else {
;;;785 if (! writable) /* reader looking at undefined data */
;;;786 ERREXIT(cinfo, JERR_BAD_VIRTUAL_ACCESS);
;;;787 }
;;;788 }
;;;789 /* Flag the buffer dirty if caller will write in it */
;;;790 if (writable)
0000cc f1b80f00 CMP r8,#0
0000d0 d001 BEQ |L2.214|
|L2.210|
;;;791 ptr->dirty = TRUE;
0000d2 2001 MOVS r0,#1
0000d4 6260 STR r0,[r4,#0x24]
|L2.214|
;;;792 /* Return address of proper part of the buffer */
;;;793 return ptr->mem_buffer + (start_row - ptr->cur_start_row);
0000d6 69a1 LDR r1,[r4,#0x18]
0000d8 6820 LDR r0,[r4,#0]
0000da 1a71 SUBS r1,r6,r1
0000dc eb000081 ADD r0,r0,r1,LSL #2
;;;794 }
0000e0 e8bd87f0 POP {r4-r10,pc}
|L2.228|
0000e4 f1b80f00 CMP r8,#0 ;785
0000e8 d1f3 BNE |L2.210|
0000ea 6829 LDR r1,[r5,#0] ;786
0000ec f8c19014 STR r9,[r1,#0x14] ;786
0000f0 6828 LDR r0,[r5,#0] ;786
0000f2 6801 LDR r1,[r0,#0] ;786
0000f4 4628 MOV r0,r5 ;786
0000f6 4788 BLX r1 ;786
0000f8 e7ed B |L2.214|
;;;795
ENDP
AREA ||i.alloc_barray||, CODE, READONLY, ALIGN=2
alloc_barray PROC
;;;425
;;;426 METHODDEF(JBLOCKARRAY) alloc_barray (j_common_ptr cinfo, int pool_id, JDIMENSION blocksperrow, JDIMENSION numrows) {
000000 e92d47f0 PUSH {r4-r10,lr}
000004 468a MOV r10,r1
000006 4681 MOV r9,r0
;;;427 /* Allocate a 2-D coefficient-block array */
;;;428 my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
;;;429 JBLOCKARRAY result;
;;;430 JBLOCKROW workspace;
;;;431 JDIMENSION rowsperchunk, currow, i;
;;;432 long ltemp;
;;;433
;;;434 /* Calculate max # of rows allowed in one allocation chunk */
;;;435 ltemp = (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr)) /
000008 6844 LDR r4,[r0,#4]
00000a 491b LDR r1,|L3.120|
00000c 01d0 LSLS r0,r2,#7
00000e fbb1f5f0 UDIV r5,r1,r0
000012 4617 MOV r7,r2 ;426
000014 461e MOV r6,r3 ;426
;;;436 ((long) blocksperrow * SIZEOF(JBLOCK));
;;;437 if (ltemp <= 0)
000016 2d00 CMP r5,#0
000018 dc08 BGT |L3.44|
;;;438 ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
00001a f8d90000 LDR r0,[r9,#0]
00001e 2146 MOVS r1,#0x46
000020 6141 STR r1,[r0,#0x14]
000022 f8d90000 LDR r0,[r9,#0]
000026 6801 LDR r1,[r0,#0]
000028 4648 MOV r0,r9
00002a 4788 BLX r1
|L3.44|
;;;439 if (ltemp < (long) numrows)
00002c 42b5 CMP r5,r6
00002e db00 BLT |L3.50|
;;;440 rowsperchunk = (JDIMENSION) ltemp;
;;;441 else
;;;442 rowsperchunk = numrows;
000030 4635 MOV r5,r6
|L3.50|
;;;443 mem->last_rowsperchunk = rowsperchunk;
000032 00b2 LSLS r2,r6,#2
;;;444
;;;445 /* Get space for row pointers (small object) */
;;;446 result = (JBLOCKARRAY) alloc_small(cinfo, pool_id,
000034 4651 MOV r1,r10
000036 4648 MOV r0,r9
000038 6525 STR r5,[r4,#0x50]
00003a f7fffffe BL alloc_small
00003e 4680 MOV r8,r0
;;;447 (size_t) (numrows * SIZEOF(JBLOCKROW)));
;;;448
;;;449 /* Get the rows themselves (large objects) */
;;;450 currow = 0;
000040 2400 MOVS r4,#0
;;;451 while (currow < numrows) {
000042 e014 B |L3.110|
|L3.68|
;;;452 rowsperchunk = MIN(rowsperchunk, numrows - currow);
000044 1b30 SUBS r0,r6,r4
000046 4629 MOV r1,r5
000048 42a8 CMP r0,r5
00004a d800 BHI |L3.78|
00004c 4601 MOV r1,r0
|L3.78|
00004e 460d MOV r5,r1
;;;453 workspace = (JBLOCKROW) alloc_large(cinfo, pool_id,
000050 4379 MULS r1,r7,r1
000052 01ca LSLS r2,r1,#7
000054 4651 MOV r1,r10
000056 4648 MOV r0,r9
000058 f7fffffe BL alloc_large
;;;454 (size_t) ((size_t) rowsperchunk * (size_t) blocksperrow
;;;455 * SIZEOF(JBLOCK)));
;;;456 for (i = rowsperchunk; i > 0; i--) {
00005c 0029 MOVS r1,r5
00005e d006 BEQ |L3.110|
|L3.96|
;;;457 result[currow++] = workspace;
000060 f8480024 STR r0,[r8,r4,LSL #2]
000064 1c64 ADDS r4,r4,#1
;;;458 workspace += blocksperrow;
000066 eb0010c7 ADD r0,r0,r7,LSL #7
00006a 1e49 SUBS r1,r1,#1 ;456
00006c d1f8 BNE |L3.96|
|L3.110|
00006e 42b4 CMP r4,r6 ;451
000070 d3e8 BCC |L3.68|
;;;459 }
;;;460 }
;;;461
;;;462 return result;
000072 4640 MOV r0,r8
;;;463 }
000074 e8bd87f0 POP {r4-r10,pc}
;;;464
ENDP
|L3.120|
DCD 0x3b9ac9f0
AREA ||i.alloc_large||, CODE, READONLY, ALIGN=2
alloc_large PROC
;;;332
;;;333 METHODDEF(void FAR *) alloc_large (j_common_ptr cinfo, int pool_id, size_t sizeofobject) /* Allocate a "large" object */ {
000000 e92d47f0 PUSH {r4-r10,lr}
000004 4606 MOV r6,r0
;;;334 my_mem_ptr mem = (my_mem_ptr) cinfo->mem;
;;;335 large_pool_ptr hdr_ptr;
;;;336 size_t odd_bytes;
;;;337
;;;338 /* Check for unsatisfiable request (do now to ensure no overflow below) */
;;;339 if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(large_pool_hdr))) {
000006 6847 LDR r7,[r0,#4]
000008 481b LDR r0,|L4.120|
00000a 4688 MOV r8,r1 ;333
00000c 4615 MOV r5,r2 ;333
00000e 4282 CMP r2,r0
000010 d903 BLS |L4.26|
;;;340 out_of_memory(cinfo, 3); /* request exceeds malloc's ability */
000012 2103 MOVS r1,#3
000014 4630 MOV r0,r6
000016 f7fffffe BL out_of_memory
|L4.26|
;;;341 }
;;;342 /* Round up the requested size to a multiple of SIZEOF(ALIGN_TYPE) */
;;;343 odd_bytes = sizeofobject % SIZEOF(ALIGN_TYPE);
00001a f0150007 ANDS r0,r5,#7
;;;344 if (odd_bytes > 0) {
00001e d002 BEQ |L4.38|
;;;345 sizeofobject += SIZEOF(ALIGN_TYPE) - odd_bytes;
000020 f1c00008 RSB r0,r0,#8
000024 4405 ADD r5,r5,r0
|L4.38|
;;;346 }
;;;347 /* Always make a new pool */
⌨️ 快捷键说明
复制代码Ctrl + C
搜索代码Ctrl + F
全屏模式F11
增大字号Ctrl + =
减小字号Ctrl + -
显示快捷键?