📄 main.lss
字号:
main.elf: file format elf32-avr
Sections:
Idx Name Size VMA LMA File off Algn
0 .text 00001772 00000000 00000000 00000094 2**1
CONTENTS, ALLOC, LOAD, READONLY, CODE
1 .data 00000112 00800060 00001772 00001806 2**0
CONTENTS, ALLOC, LOAD, DATA
2 .bss 0000001d 00800172 00800172 00001918 2**0
ALLOC
3 .debug_aranges 000000a0 00000000 00000000 00001918 2**0
CONTENTS, READONLY, DEBUGGING
4 .debug_pubnames 000001a3 00000000 00000000 000019b8 2**0
CONTENTS, READONLY, DEBUGGING
5 .debug_info 00001775 00000000 00000000 00001b5b 2**0
CONTENTS, READONLY, DEBUGGING
6 .debug_abbrev 0000066d 00000000 00000000 000032d0 2**0
CONTENTS, READONLY, DEBUGGING
7 .debug_line 00001013 00000000 00000000 0000393d 2**0
CONTENTS, READONLY, DEBUGGING
8 .debug_frame 00000200 00000000 00000000 00004950 2**2
CONTENTS, READONLY, DEBUGGING
9 .debug_str 0000045c 00000000 00000000 00004b50 2**0
CONTENTS, READONLY, DEBUGGING
10 .debug_loc 00000891 00000000 00000000 00004fac 2**0
CONTENTS, READONLY, DEBUGGING
11 .debug_ranges 00000088 00000000 00000000 0000583d 2**0
CONTENTS, READONLY, DEBUGGING
Disassembly of section .text:
00000000 <__vectors>:
0: 31 c0 rjmp .+98 ; 0x64 <__ctors_end>
2: 4b c0 rjmp .+150 ; 0x9a <__bad_interrupt>
4: 4a c0 rjmp .+148 ; 0x9a <__bad_interrupt>
6: 49 c0 rjmp .+146 ; 0x9a <__bad_interrupt>
8: 48 c0 rjmp .+144 ; 0x9a <__bad_interrupt>
a: 47 c0 rjmp .+142 ; 0x9a <__bad_interrupt>
c: 46 c0 rjmp .+140 ; 0x9a <__bad_interrupt>
e: 45 c0 rjmp .+138 ; 0x9a <__bad_interrupt>
10: 44 c0 rjmp .+136 ; 0x9a <__bad_interrupt>
12: 43 c0 rjmp .+134 ; 0x9a <__bad_interrupt>
14: 42 c0 rjmp .+132 ; 0x9a <__bad_interrupt>
16: 41 c0 rjmp .+130 ; 0x9a <__bad_interrupt>
18: 40 c0 rjmp .+128 ; 0x9a <__bad_interrupt>
1a: 3f c0 rjmp .+126 ; 0x9a <__bad_interrupt>
1c: ee c4 rjmp .+2524 ; 0x9fa <__vector_14>
1e: 3d c0 rjmp .+122 ; 0x9a <__bad_interrupt>
20: 3c c0 rjmp .+120 ; 0x9a <__bad_interrupt>
22: 3b c0 rjmp .+118 ; 0x9a <__bad_interrupt>
24: 3a c0 rjmp .+116 ; 0x9a <__bad_interrupt>
00000026 <c.1791>:
26: 61 6c 72 65 61 64 79 20 73 74 6f 72 65 64 00 already stored.
00000035 <c.1789>:
35: 74 75 78 67 72 61 70 68 69 63 73 2e 6f 72 67 00 tuxgraphics.org.
00000045 <c.1787>:
45: 76 65 72 3a 20 64 64 63 70 2d 30 2e 35 2e 30 00 ver: ddcp-0.5.0.
00000055 <c.1785>:
55: 73 65 74 74 69 6e 67 20 73 74 6f 72 65 64 00 setting stored.
00000064 <__ctors_end>:
64: 11 24 eor r1, r1
66: 1f be out 0x3f, r1 ; 63
68: cf e5 ldi r28, 0x5F ; 95
6a: d4 e0 ldi r29, 0x04 ; 4
6c: de bf out 0x3e, r29 ; 62
6e: cd bf out 0x3d, r28 ; 61
00000070 <__do_copy_data>:
70: 11 e0 ldi r17, 0x01 ; 1
72: a0 e6 ldi r26, 0x60 ; 96
74: b0 e0 ldi r27, 0x00 ; 0
76: e2 e7 ldi r30, 0x72 ; 114
78: f7 e1 ldi r31, 0x17 ; 23
7a: 02 c0 rjmp .+4 ; 0x80 <.do_copy_data_start>
0000007c <.do_copy_data_loop>:
7c: 05 90 lpm r0, Z+
7e: 0d 92 st X+, r0
00000080 <.do_copy_data_start>:
80: a2 37 cpi r26, 0x72 ; 114
82: b1 07 cpc r27, r17
84: d9 f7 brne .-10 ; 0x7c <.do_copy_data_loop>
00000086 <__do_clear_bss>:
86: 11 e0 ldi r17, 0x01 ; 1
88: a2 e7 ldi r26, 0x72 ; 114
8a: b1 e0 ldi r27, 0x01 ; 1
8c: 01 c0 rjmp .+2 ; 0x90 <.do_clear_bss_start>
0000008e <.do_clear_bss_loop>:
8e: 1d 92 st X+, r1
00000090 <.do_clear_bss_start>:
90: af 38 cpi r26, 0x8F ; 143
92: b1 07 cpc r27, r17
94: e1 f7 brne .-8 ; 0x8e <.do_clear_bss_loop>
96: 8c d1 rcall .+792 ; 0x3b0 <main>
98: 6a cb rjmp .-2348 ; 0xfffff76e <__eeprom_end+0xff7ef76e>
0000009a <__bad_interrupt>:
9a: b2 cf rjmp .-156 ; 0x0 <__vectors>
0000009c <eeprom_read_byte>:
/** \ingroup avr_eeprom
Read one byte from EEPROM address \a __p.
*/
__ATTR_PURE__ static __inline__ uint8_t eeprom_read_byte (const uint8_t *__p)
{
9c: 9c 01 movw r18, r24
do {} while (!eeprom_is_ready ());
9e: e1 99 sbic 0x1c, 1 ; 28
a0: fe cf rjmp .-4 ; 0x9e <eeprom_read_byte+0x2>
#if E2END <= 0xFF
EEARL = (size_t)__p;
#else
EEAR = (size_t)__p;
a2: 3f bb out 0x1f, r19 ; 31
a4: 2e bb out 0x1e, r18 ; 30
/* Use inline assembly below as some AVRs have problems with accessing
EECR with STS instructions. For example, see errata for ATmega64.
The code below also assumes that EECR and EEDR are in the I/O space.
*/
uint8_t __result;
__asm__ __volatile__
a6: e0 9a sbi 0x1c, 0 ; 28
a8: 8d b3 in r24, 0x1d ; 29
: "i" (_SFR_IO_ADDR(EECR)),
"i" (EERE),
"i" (_SFR_IO_ADDR(EEDR))
);
return __result;
}
aa: 08 95 ret
000000ac <eeprom_write_byte>:
/** \ingroup avr_eeprom
Write a byte \a __value to EEPROM address \a __p.
*/
static __inline__ void eeprom_write_byte (uint8_t *__p, uint8_t __value)
{
ac: 9c 01 movw r18, r24
do {} while (!eeprom_is_ready ());
ae: e1 99 sbic 0x1c, 1 ; 28
b0: fe cf rjmp .-4 ; 0xae <eeprom_write_byte+0x2>
#endif
#if E2END <= 0xFF
EEARL = (size_t)__p;
#else
EEAR = (size_t)__p;
b2: 3f bb out 0x1f, r19 ; 31
b4: 2e bb out 0x1e, r18 ; 30
#endif
EEDR = __value;
b6: 6d bb out 0x1d, r22 ; 29
__asm__ __volatile__ (
b8: 0f b6 in r0, 0x3f ; 63
ba: f8 94 cli
bc: e2 9a sbi 0x1c, 2 ; 28
be: e1 9a sbi 0x1c, 1 ; 28
c0: 0f be out 0x3f, r0 ; 63
[__sreg] "i" (_SFR_IO_ADDR(SREG)),
[__eemwe] "i" (EEMWE),
[__eewe] "i" (EEWE)
: "r0"
);
}
c2: 08 95 ret
000000c4 <delay_ms>:
milliseconds can be achieved.
*/
void
_delay_loop_2(uint16_t __count)
{
__asm__ volatile (
c4: 20 ec ldi r18, 0xC0 ; 192
c6: 33 e0 ldi r19, 0x03 ; 3
c8: 04 c0 rjmp .+8 ; 0xd2 <delay_ms+0xe>
ca: f9 01 movw r30, r18
cc: 31 97 sbiw r30, 0x01 ; 1
ce: f1 f7 brne .-4 ; 0xcc <delay_ms+0x8>
// we use a calibrated macro. This is more
// accurate and not so much compiler dependent
// as self made code.
while(ms){
_delay_ms(0.96);
ms--;
d0: 01 97 sbiw r24, 0x01 ; 1
/* delay for a minimum of <ms> */
{
// we use a calibrated macro. This is more
// accurate and not so much compiler dependent
// as self made code.
while(ms){
d2: 00 97 sbiw r24, 0x00 ; 0
d4: d1 f7 brne .-12 ; 0xca <delay_ms+0x6>
_delay_ms(0.96);
ms--;
}
}
d6: 08 95 ret
000000d8 <int_to_ascii>:
// Convert a integer which is representing a float into a string.
// decimalpoint_pos sets the decimal point after 2 pos: e.g 74 becomes "0.74"
// The integer may not be larger than 10000.
// The integer must be a positive number.
// spacepadd can be used to add a leading speace if number is less than 10
static void int_to_ascii(int inum,char *outbuf,signed char decimalpoint_pos,signed char spacepadd){
d8: 5f 92 push r5
da: 6f 92 push r6
dc: 7f 92 push r7
de: 8f 92 push r8
e0: 9f 92 push r9
e2: af 92 push r10
e4: bf 92 push r11
e6: cf 92 push r12
e8: df 92 push r13
ea: ef 92 push r14
ec: ff 92 push r15
ee: 0f 93 push r16
f0: 1f 93 push r17
f2: df 93 push r29
f4: cf 93 push r28
f6: cd b7 in r28, 0x3d ; 61
f8: de b7 in r29, 0x3e ; 62
fa: 28 97 sbiw r28, 0x08 ; 8
fc: 0f b6 in r0, 0x3f ; 63
fe: f8 94 cli
100: de bf out 0x3e, r29 ; 62
102: 0f be out 0x3f, r0 ; 63
104: cd bf out 0x3d, r28 ; 61
106: 8c 01 movw r16, r24
108: 3b 01 movw r6, r22
10a: e4 2e mov r14, r20
10c: b2 2e mov r11, r18
10e: ff 24 eor r15, r15
signed char i,j;
char chbuf[8];
j=0;
while(inum>9 && j<7){
// zero is ascii 48:
chbuf[j]=(char)48+ inum-((inum/10)*10);
110: 4e 01 movw r8, r28
112: 08 94 sec
114: 81 1c adc r8, r1
116: 91 1c adc r9, r1
inum=inum/10;
j++;
if(decimalpoint_pos==j){
chbuf[j]='.';
118: c4 2e mov r12, r20
11a: dd 24 eor r13, r13
11c: c7 fc sbrc r12, 7
11e: d0 94 com r13
120: c8 0c add r12, r8
122: d9 1c adc r13, r9
124: 7e e2 ldi r23, 0x2E ; 46
126: 57 2e mov r5, r23
j++;
128: a4 2e mov r10, r20
12a: a3 94 inc r10
12c: 24 c0 rjmp .+72 ; 0x176 <int_to_ascii+0x9e>
signed char i,j;
char chbuf[8];
j=0;
while(inum>9 && j<7){
// zero is ascii 48:
chbuf[j]=(char)48+ inum-((inum/10)*10);
12e: ef 2d mov r30, r15
130: ff 27 eor r31, r31
132: e7 fd sbrc r30, 7
134: f0 95 com r31
136: e8 0d add r30, r8
138: f9 1d adc r31, r9
13a: 40 2f mov r20, r16
13c: 40 5d subi r20, 0xD0 ; 208
13e: c8 01 movw r24, r16
140: 66 ef ldi r22, 0xF6 ; 246
142: 7f ef ldi r23, 0xFF ; 255
144: b6 da rcall .-2708 ; 0xfffff6b2 <__eeprom_end+0xff7ef6b2>
146: cb 01 movw r24, r22
148: 9b 01 movw r18, r22
14a: 63 e0 ldi r22, 0x03 ; 3
14c: 22 0f add r18, r18
14e: 33 1f adc r19, r19
150: 6a 95 dec r22
152: e1 f7 brne .-8 ; 0x14c <int_to_ascii+0x74>
154: 88 0f add r24, r24
156: 99 1f adc r25, r25
158: 28 0f add r18, r24
15a: 39 1f adc r19, r25
15c: 42 0f add r20, r18
15e: 40 83 st Z, r20
inum=inum/10;
j++;
160: f3 94 inc r15
if(decimalpoint_pos==j){
162: ef 14 cp r14, r15
164: 19 f4 brne .+6 ; 0x16c <int_to_ascii+0x94>
chbuf[j]='.';
166: f6 01 movw r30, r12
168: 50 82 st Z, r5
j++;
16a: fa 2c mov r15, r10
char chbuf[8];
j=0;
while(inum>9 && j<7){
// zero is ascii 48:
chbuf[j]=(char)48+ inum-((inum/10)*10);
inum=inum/10;
16c: c8 01 movw r24, r16
16e: 6a e0 ldi r22, 0x0A ; 10
170: 70 e0 ldi r23, 0x00 ; 0
172: 9f da rcall .-2754 ; 0xfffff6b2 <__eeprom_end+0xff7ef6b2>
174: 8b 01 movw r16, r22
// spacepadd can be used to add a leading speace if number is less than 10
static void int_to_ascii(int inum,char *outbuf,signed char decimalpoint_pos,signed char spacepadd){
signed char i,j;
char chbuf[8];
j=0;
while(inum>9 && j<7){
176: 0a 30 cpi r16, 0x0A ; 10
178: 11 05 cpc r17, r1
17a: 1c f0 brlt .+6 ; 0x182 <int_to_ascii+0xaa>
17c: f6 e0 ldi r31, 0x06 ; 6
17e: ff 15 cp r31, r15
180: b4 f6 brge .-84 ; 0x12e <int_to_ascii+0x56>
182: 5f 2d mov r21, r15
if(decimalpoint_pos==j){
chbuf[j]='.';
j++;
}
}
chbuf[j]=(char)48+inum; // most significant digit
184: ef 2d mov r30, r15
186: ff 27 eor r31, r31
188: e7 fd sbrc r30, 7
18a: f0 95 com r31
18c: 9e 01 movw r18, r28
18e: 2f 5f subi r18, 0xFF ; 255
190: 3f 4f sbci r19, 0xFF ; 255
192: e2 0f add r30, r18
194: f3 1f adc r31, r19
196: 80 2f mov r24, r16
198: 80 5d subi r24, 0xD0 ; 208
19a: 80 83 st Z, r24
decimalpoint_pos--;
19c: 4e 2d mov r20, r14
19e: 41 50 subi r20, 0x01 ; 1
1a0: 5f 5f subi r21, 0xFF ; 255
1a2: e5 2f mov r30, r21
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -