W dniu 05.04.2014 o 18:12 Sylwester Łazar <i...@a...pl> pisze:

>
>> Avr studio4 zlicz() - 132 bajty
>> całość 356 bajtów.
>
> Możesz wkleić kod po kompilacji?
Ok, poniżej.
> W ATMEGA są zdaje się instrukcje 16-bitowe.
tak
> W takim razie oznacza to, że jest <66 instrukcji?
65

Kod:

sort.elf: file format elf32-avr

Sections:
Idx Name Size VMA LMA File off Algn
0 .text 00000166 00000000 00000000 00000094 2**1
CONTENTS, ALLOC, LOAD, READONLY, CODE
1 .data 00000002 00800060 00000166 000001fa 2**0
CONTENTS, ALLOC, LOAD, DATA
2 .bss 00000023 00800062 00800062 000001fc 2**0
ALLOC
3 .debug_aranges 00000020 00000000 00000000 000001fc 2**0
CONTENTS, READONLY, DEBUGGING
4 .debug_pubnames 00000067 00000000 00000000 0000021c 2**0
CONTENTS, READONLY, DEBUGGING
5 .debug_info 00000116 00000000 00000000 00000283 2**0
CONTENTS, READONLY, DEBUGGING
6 .debug_abbrev 000000ab 00000000 00000000 00000399 2**0
CONTENTS, READONLY, DEBUGGING
7 .debug_line 00000145 00000000 00000000 00000444 2**0
CONTENTS, READONLY, DEBUGGING
8 .debug_frame 00000030 00000000 00000000 0000058c 2**2
CONTENTS, READONLY, DEBUGGING
9 .debug_str 0000005e 00000000 00000000 000005bc 2**0
CONTENTS, READONLY, DEBUGGING

Disassembly of section .text:

00000000 <__vectors>:
0: 0c 94 2a 00 jmp 0x54 ; 0x54 <__ctors_end>
4: 0c 94 47 00 jmp 0x8e ; 0x8e <__bad_interrupt>
8: 0c 94 47 00 jmp 0x8e ; 0x8e <__bad_interrupt>
c: 0c 94 47 00 jmp 0x8e ; 0x8e <__bad_interrupt>
10: 0c 94 47 00 jmp 0x8e ; 0x8e <__bad_interrupt>
14: 0c 94 47 00 jmp 0x8e ; 0x8e <__bad_interrupt>
18: 0c 94 47 00 jmp 0x8e ; 0x8e <__bad_interrupt>
1c: 0c 94 47 00 jmp 0x8e ; 0x8e <__bad_interrupt>
20: 0c 94 47 00 jmp 0x8e ; 0x8e <__bad_interrupt>
24: 0c 94 47 00 jmp 0x8e ; 0x8e <__bad_interrupt>
28: 0c 94 47 00 jmp 0x8e ; 0x8e <__bad_interrupt>
2c: 0c 94 47 00 jmp 0x8e ; 0x8e <__bad_interrupt>
30: 0c 94 47 00 jmp 0x8e ; 0x8e <__bad_interrupt>
34: 0c 94 47 00 jmp 0x8e ; 0x8e <__bad_interrupt>
38: 0c 94 47 00 jmp 0x8e ; 0x8e <__bad_interrupt>
3c: 0c 94 47 00 jmp 0x8e ; 0x8e <__bad_interrupt>
40: 0c 94 47 00 jmp 0x8e ; 0x8e <__bad_interrupt>
44: 0c 94 47 00 jmp 0x8e ; 0x8e <__bad_interrupt>
48: 0c 94 47 00 jmp 0x8e ; 0x8e <__bad_interrupt>
4c: 0c 94 47 00 jmp 0x8e ; 0x8e <__bad_interrupt>
50: 0c 94 47 00 jmp 0x8e ; 0x8e <__bad_interrupt>

00000054 <__ctors_end>:
54: 11 24 eor r1, r1
56: 1f be out 0x3f, r1 ; 63
58: cf e5 ldi r28, 0x5F ; 95
5a: d8 e0 ldi r29, 0x08 ; 8
5c: de bf out 0x3e, r29 ; 62
5e: cd bf out 0x3d, r28 ; 61

00000060 <__do_copy_data>:
60: 10 e0 ldi r17, 0x00 ; 0
62: a0 e6 ldi r26, 0x60 ; 96
64: b0 e0 ldi r27, 0x00 ; 0
66: e6 e6 ldi r30, 0x66 ; 102
68: f1 e0 ldi r31, 0x01 ; 1
6a: 02 c0 rjmp .+4 ; 0x70 <.do_copy_data_start>

0000006c <.do_copy_data_loop>:
6c: 05 90 lpm r0, Z+
6e: 0d 92 st X+, r0

00000070 <.do_copy_data_start>:
70: a2 36 cpi r26, 0x62 ; 98
72: b1 07 cpc r27, r17
74: d9 f7 brne .-10 ; 0x6c <.do_copy_data_loop>

00000076 <__do_clear_bss>:
76: 10 e0 ldi r17, 0x00 ; 0
78: a2 e6 ldi r26, 0x62 ; 98
7a: b0 e0 ldi r27, 0x00 ; 0
7c: 01 c0 rjmp .+2 ; 0x80 <.do_clear_bss_start>

0000007e <.do_clear_bss_loop>:
7e: 1d 92 st X+, r1

00000080 <.do_clear_bss_start>:
80: a5 38 cpi r26, 0x85 ; 133
82: b1 07 cpc r27, r17
84: e1 f7 brne .-8 ; 0x7e <.do_clear_bss_loop>
86: 0e 94 8b 00 call 0x116 ; 0x116 <main>
8a: 0c 94 b1 00 jmp 0x162 ; 0x162 <_exit>

0000008e <__bad_interrupt>:
8e: 0c 94 00 00 jmp 0 ; 0x0 <__vectors>

00000092 <zlicz>:
ADRDIOD[4][0]=2;
ADRDIOD[4][1]=1;
zlicz();
}

void zlicz(){
92: e0 e8 ldi r30, 0x80 ; 128
94: f0 e0 ldi r31, 0x00 ; 0

char i; // zmienna pomocnicza
char j; // zmienna pomocnicza

for(i = 0 ; i < k ; ++i)
LICZV[i] = 0; // zerowanie tablicy
96: 11 92 st Z+, r1
void zlicz(){

char i; // zmienna pomocnicza
char j; // zmienna pomocnicza

for(i = 0 ; i < k ; ++i)
98: 80 e0 ldi r24, 0x00 ; 0
9a: e7 38 cpi r30, 0x87 ; 135
9c: f8 07 cpc r31, r24
9e: d9 f7 brne .-10 ; 0x96 <zlicz+0x4>
a0: a2 e6 ldi r26, 0x62 ; 98
a2: b0 e0 ldi r27, 0x00 ; 0
LICZV[i] = 0; // zerowanie tablicy

for(i = 0 ; i < n ; ++i)
++LICZV[VDIOD[i]]; // po tych operacjach LICZV[i] będzie
zawierała
a4: ed 91 ld r30, X+
a6: f0 e0 ldi r31, 0x00 ; 0
a8: e0 58 subi r30, 0x80 ; 128
aa: ff 4f sbci r31, 0xFF ; 255
ac: 80 81 ld r24, Z
ae: 8f 5f subi r24, 0xFF ; 255
b0: 80 83 st Z, r24
char j; // zmienna pomocnicza

for(i = 0 ; i < k ; ++i)
LICZV[i] = 0; // zerowanie tablicy

for(i = 0 ; i < n ; ++i)
b2: 80 e0 ldi r24, 0x00 ; 0
b4: a7 36 cpi r26, 0x67 ; 103
b6: b8 07 cpc r27, r24
b8: a9 f7 brne .-22 ; 0xa4 <zlicz+0x12>
ba: e0 e8 ldi r30, 0x80 ; 128
bc: f0 e0 ldi r31, 0x00 ; 0
++LICZV[VDIOD[i]]; // po tych operacjach LICZV[i] będzie
zawierała
// liczbę wystąpień elementów o kluczu i
for(i = 1 ; i < k ; ++i)
LICZV[i] += LICZV[i-1]; // teraz LICZV[i] zawiera pozycje w
posortowanej
be: 81 81 ldd r24, Z+1 ; 0x01
c0: 90 81 ld r25, Z
c2: 89 0f add r24, r25
c4: 81 83 std Z+1, r24 ; 0x01
c6: 31 96 adiw r30, 0x01 ; 1
LICZV[i] = 0; // zerowanie tablicy

for(i = 0 ; i < n ; ++i)
++LICZV[VDIOD[i]]; // po tych operacjach LICZV[i] będzie
zawierała
// liczbę wystąpień elementów o kluczu i
for(i = 1 ; i < k ; ++i)
c8: a0 e0 ldi r26, 0x00 ; 0
ca: e6 38 cpi r30, 0x86 ; 134
cc: fa 07 cpc r31, r26
ce: b9 f7 brne .-18 ; 0xbe <zlicz+0x2c>
d0: 34 e0 ldi r19, 0x04 ; 4
LICZV[i] += LICZV[i-1]; // teraz LICZV[i] zawiera pozycje w
posortowanej
// tablicy ostatniego elementu o kluczu i
for(i = n-1 ; i >= 0 ; --i)
{
j=--LICZV[VDIOD[i]]; // aktualizacja LICZV
d2: 83 2f mov r24, r19
d4: 90 e0 ldi r25, 0x00 ; 0
d6: fc 01 movw r30, r24
d8: ee 59 subi r30, 0x9E ; 158
da: ff 4f sbci r31, 0xFF ; 255
dc: 20 81 ld r18, Z
de: a2 2f mov r26, r18
e0: b0 e0 ldi r27, 0x00 ; 0
e2: a0 58 subi r26, 0x80 ; 128
e4: bf 4f sbci r27, 0xFF ; 255
e6: ec 91 ld r30, X
e8: e1 50 subi r30, 0x01 ; 1
ea: ec 93 st X, r30
VDOUT[j] = VDIOD[i]; //wstawienie elementu na odpowiednią pozycję
ec: f0 e0 ldi r31, 0x00 ; 0
ee: df 01 movw r26, r30
f0: a5 58 subi r26, 0x85 ; 133
f2: bf 4f sbci r27, 0xFF ; 255
f4: 2c 93 st X, r18
ADRDOUT[j][0] = ADRDIOD[i][0]; // sortowanie adresów
f6: ee 0f add r30, r30
f8: ff 1f adc r31, r31
fa: e9 59 subi r30, 0x99 ; 153
fc: ff 4f sbci r31, 0xFF ; 255
fe: 88 0f add r24, r24
100: 99 1f adc r25, r25
102: 8f 58 subi r24, 0x8F ; 143
104: 9f 4f sbci r25, 0xFF ; 255
106: dc 01 movw r26, r24
108: 2c 91 ld r18, X
10a: 20 83 st Z, r18
ADRDOUT[j][1] = ADRDIOD[i][1]; // sortowanie adresów
10c: 11 96 adiw r26, 0x01 ; 1
10e: 8c 91 ld r24, X
110: 81 83 std Z+1, r24 ; 0x01
++LICZV[VDIOD[i]]; // po tych operacjach LICZV[i] będzie
zawierała
// liczbę wystąpień elementów o kluczu i
for(i = 1 ; i < k ; ++i)
LICZV[i] += LICZV[i-1]; // teraz LICZV[i] zawiera pozycje w
posortowanej
// tablicy ostatniego elementu o kluczu i
for(i = n-1 ; i >= 0 ; --i)
112: 31 50 subi r19, 0x01 ; 1
114: de cf rjmp .-68 ; 0xd2 <zlicz+0x40>

00000116 <main>:
char ADRDIOD[5][2];//tablica adresów diod
char ADRDOUT[5][2];//tablica adresów diod po posegregowaniu
char LICZV[5]; // zawiera liczbę elementów o danej wartości

void main (void){
VDIOD[0]=1;
116: 91 e0 ldi r25, 0x01 ; 1
118: 90 93 62 00 sts 0x0062, r25
VDIOD[1]=2;
11c: 22 e0 ldi r18, 0x02 ; 2
11e: 20 93 63 00 sts 0x0063, r18
VDIOD[2]=6;
122: 86 e0 ldi r24, 0x06 ; 6
124: 80 93 64 00 sts 0x0064, r24
VDIOD[3]=4;
128: 84 e0 ldi r24, 0x04 ; 4
12a: 80 93 65 00 sts 0x0065, r24
VDIOD[4]=3;
12e: 83 e0 ldi r24, 0x03 ; 3
130: 80 93 66 00 sts 0x0066, r24
ADRDIOD[0][0]=1;
134: 90 93 71 00 sts 0x0071, r25
ADRDIOD[0][1]=0;
138: 10 92 72 00 sts 0x0072, r1
ADRDIOD[1][0]=1;
13c: 90 93 73 00 sts 0x0073, r25
ADRDIOD[1][1]=1;
140: 90 93 74 00 sts 0x0074, r25
ADRDIOD[2][0]=1;
144: 90 93 75 00 sts 0x0075, r25
ADRDIOD[2][1]=2;
148: 20 93 76 00 sts 0x0076, r18
ADRDIOD[3][0]=2;
14c: 20 93 77 00 sts 0x0077, r18
ADRDIOD[3][1]=0;
150: 10 92 78 00 sts 0x0078, r1
ADRDIOD[4][0]=2;
154: 20 93 79 00 sts 0x0079, r18
ADRDIOD[4][1]=1;
158: 90 93 7a 00 sts 0x007A, r25
zlicz();
15c: 0e 94 49 00 call 0x92 ; 0x92 <zlicz>
}
160: 08 95 ret

00000162 <_exit>:
162: f8 94 cli

00000164 <__stop_program>:
164: ff cf rjmp .-2 ; 0x164 <__stop_program>



--

Pozdr
Janusz