avr-g++ bindet ungenutzen code mit ein!

hans Gast #1007301
Lesenswert?
• ▲
▼ 
Hallo zusammen,

und zwar verwende ich seit neustem den avr-g++ compilier. Was mich nun 
stört ist folgendes und zwar, ich binde mehrere Dateien in mein Projekt 
ein, verwende den darin enthaltenen code aber nicht von allen dateien, 
er compiliert die dinger aber trotzdem mit und das .hex-file wird so 
rießig groß. gibts da ne einstellung wo man ungenutzte ausbinden kann?


Danke,
hans
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Gast Gast #1010801
Lesenswert?
• ▲
▼ 
Mit der Option gc-sections kann der Linker die nicht benutzten 
Funktionen herausfiltern. Vorausgesetzt du hast deinen Quellcode mit 
-ffunction-sections und -fdata-sections compiliert.
Für ein C++-Projekt auf einem AVR-Target verwende ich beispielsweise 
folgende Einstellungen für g++:
1
-Os -gdwarf-2 -Wall -c -mmcu=atmega328p  -mno-tablejump -mcall-prologues -fmessage-length=0 -fshort-enums -fno-rtti -fno-exceptions -ffunction-sections  -fdata-sections

Für den Linker-Pass über das gcc-Frontend folgende Optionen:
1
-mmcu=atmega328p -static -Wl,--relax -Wl,--gc-sections


Anmerkungen:
Bei -fno-tablejumps musst du experimentieren, ob's was bringt.
Die --relax Option sorgt dafür, dass der Linker absolute Sprünge durch 
relative Sprünge die 1 Byte weniger brauchen, ersetzt. Hat bei mir 
nochmals ca. 500 Bytes gespart.

Achja: Ich verwende den GCC 4.2.2
Antwort Zitieren Bearbeiten Löschen Beitrag melden
holger Gast #1010833
Lesenswert?
• ▲
▼ 
>Die --relax Option sorgt dafür, dass der Linker absolute Sprünge durch
>relative Sprünge die 1 Byte weniger brauchen, ersetzt. Hat bei mir
>nochmals ca. 500 Bytes gespart.

Goil! Das --relax bringt bei einigen meiner C
Programme auch noch mal bis zu 400 freie Bytes.
Programmgröße ungefähr 10kB Flash Bedarf.

Wieso muss man solche Optionen eigentlich erst im Forum
finden? Warum sind die nicht "DEFAULT"?

Ok, Programm hab ich damit noch nicht ausprobiert.
Nur compiliert.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
DerDan Gast #1015520
Lesenswert?
• ▲
▼ 
Hallo,


wenn ich

1
-ffunction-sections

und
1
-Wl,--gc-sections


verwende, dann erzeugt der linker ein leers file

und es kommt die Meldung:

1
avr-objcopy: there are no sections to be copied!


ich verwende ein eigenes Linker Script. Wenn ich das nicht angebe, dann
wird ein File generiert.

also muss ich etwas in meinem Linker Script ändern. Nur was?

1
OUTPUT_FORMAT("elf32-avr","elf32-avr","elf32-avr")

2
OUTPUT_ARCH(avr:4)

3
MEMORY

4
{

5
  text   (rx)   : ORIGIN = 0, LENGTH = 16K - 2k - 128

6
  text2  (rx)   : ORIGIN = 16K - 2K - 128,  LENGTH = 128

7
  data   (rw!x) : ORIGIN = 0x800060, LENGTH = 0xffa0

8
  eeprom (rw!x) : ORIGIN = 0x810000, LENGTH = 512

9
}

10
SECTIONS

11
{

12
  /* Read-only sections, merged into text segment: */

13
  .hash          : { *(.hash)    }

14
  .dynsym        : { *(.dynsym)    }

15
  .dynstr        : { *(.dynstr)    }

16
  .gnu.version   : { *(.gnu.version)  }

17
  .gnu.version_d   : { *(.gnu.version_d)  }

18
  .gnu.version_r   : { *(.gnu.version_r)  }

19
  .rel.init      : { *(.rel.init)    }

20
  .rela.init     : { *(.rela.init)  }

21
  .rel.text      :

22
    {

23
      *(.rel.text)

24
      *(.rel.text.*)

25
      *(.rel.gnu.linkonce.t*)

26
    }

27
  .rela.text     :

28
    {

29
      *(.rela.text)

30
      *(.rela.text.*)

31
      *(.rela.gnu.linkonce.t*)

32
    }

33
  .rel.fini      : { *(.rel.fini)    }

34
  .rela.fini     : { *(.rela.fini)  }

35
  .rel.rodata    :

36
    {

37
      *(.rel.rodata)

38
      *(.rel.rodata.*)

39
      *(.rel.gnu.linkonce.r*)

40
    }

41
  .rela.rodata   :

42
    {

43
      *(.rela.rodata)

44
      *(.rela.rodata.*)

45
      *(.rela.gnu.linkonce.r*)

46
    }

47
  .rel.data      :

48
    {

49
      *(.rel.data)

50
      *(.rel.data.*)

51
      *(.rel.gnu.linkonce.d*)

52
    }

53
  .rela.data     :

54
    {

55
      *(.rela.data)

56
      *(.rela.data.*)

57
      *(.rela.gnu.linkonce.d*)

58
    }

59
  .rel.ctors     : { *(.rel.ctors)  }

60
  .rela.ctors    : { *(.rela.ctors)  }

61
  .rel.dtors     : { *(.rel.dtors)  }

62
  .rela.dtors    : { *(.rela.dtors)  }

63
  .rel.got       : { *(.rel.got)    }

64
  .rela.got      : { *(.rela.got)    }

65
  .rel.bss       : { *(.rel.bss)    }

66
  .rela.bss      : { *(.rela.bss)    }

67
  .rel.plt       : { *(.rel.plt)    }

68
  .rela.plt      : { *(.rela.plt)    }

69
  /* Internal text space or external memory */

70
  .text :

71
  {

72
    __vectors_update0 = absolute (16k  - 2k);

73
    *(.vectors)

74
    /*

75
    *(.version)

76
    *(.device)

77
    */

78
     __ctors_start = . ;

79
     *(.ctors)

80
     __ctors_end = . ;

81
     __dtors_start = . ;

82
     *(.dtors)

83
     __dtors_end = . ;

84
    *(.progmem.gcc*)

85
    *(.progmem*)

86
    . = ALIGN(2);

87
    *(.init0)  /* Start here after reset.  */

88
    *(.init1)

89
    *(.init2)  /* Clear __zero_reg__, set up stack pointer.  */

90
    *(.init3)

91
    *(.init4)  /* Initialize data and BSS.  */

92
    *(.init5)

93
    *(.init6)  /* C++ constructors.  */

94
    *(.init7)

95
    *(.init8)

96
    *(.init9)  /* Call main().  */

97
    *(.text)

98
    . = ALIGN(2);

99
    *(.text.*)

100
    . = ALIGN(2);

101
    *(.fini9)  /* _exit() starts here.  */

102
    *(.fini8)

103
    *(.fini7)

104
    *(.fini6)  /* C++ destructors.  */

105
    *(.fini5)

106
    *(.fini4)

107
    *(.fini3)

108
    *(.fini2)

109
    *(.fini1)

110
    *(.fini0)  /* Infinite loop after program termination.  */

111
     _etext = . ;

112
  }  > text

113
  .data    : AT (ADDR (.text) + SIZEOF (.text))

114
  {

115
     PROVIDE (__data_start = .) ;

116
    *(.data)

117
    *(.gnu.linkonce.d*)

118
    . = ALIGN(2);

119
     _edata = . ;

120
     PROVIDE (__data_end = .) ;

121
  }  > data

122
  .text2 :

123
  {

124
    *(.signature)

125
  } > text2

126
  .bss  SIZEOF(.data) + ADDR(.data) :

127
  {

128
     PROVIDE (__bss_start = .) ;

129
    *(.bss)

130
    *(COMMON)

131
     PROVIDE (__bss_end = .) ;

132
  }  > data

133
   __data_load_start = LOADADDR(.data);

134
   __data_load_end = __data_load_start + SIZEOF(.data);

135
  /* Global data not cleared after reset.  */

136
  .noinit  SIZEOF(.bss) + ADDR(.bss) :

137
  {

138
     PROVIDE (__noinit_start = .) ;

139
    *(.noinit*)

140
     PROVIDE (__noinit_end = .) ;

141
     _end = . ;

142
     PROVIDE (__heap_start = .) ;

143
  }  > data

144
  .eeprom  :

145
  {

146
    *(.eeprom*)

147
     __eeprom_end = . ;

148
  }  > eeprom

149
  /* Stabs debugging sections.  */

150
  .stab 0 : { *(.stab) }

151
  .stabstr 0 : { *(.stabstr) }

152
  .stab.excl 0 : { *(.stab.excl) }

153
  .stab.exclstr 0 : { *(.stab.exclstr) }

154
  .stab.index 0 : { *(.stab.index) }

155
  .stab.indexstr 0 : { *(.stab.indexstr) }

156
  .comment 0 : { *(.comment) }

157
  /* DWARF debug sections.

158
     Symbols in the DWARF debugging sections are relative to the beginning

159
     of the section so we begin them at 0.  */

160
  /* DWARF 1 */

161
  .debug          0 : { *(.debug) }

162
  .line           0 : { *(.line) }

163
  /* GNU DWARF 1 extensions */

164
  .debug_srcinfo  0 : { *(.debug_srcinfo) }

165
  .debug_sfnames  0 : { *(.debug_sfnames) }

166
  /* DWARF 1.1 and DWARF 2 */

167
  .debug_aranges  0 : { *(.debug_aranges) }

168
  .debug_pubnames 0 : { *(.debug_pubnames) }

169
  /* DWARF 2 */

170
  .debug_info     0 : { *(.debug_info) *(.gnu.linkonce.wi.*) }

171
  .debug_abbrev   0 : { *(.debug_abbrev) }

172
  .debug_line     0 : { *(.debug_line) }

173
  .debug_frame    0 : { *(.debug_frame) }

174
  .debug_str      0 : { *(.debug_str) }

175
  .debug_loc      0 : { *(.debug_loc) }

176
  .debug_macinfo  0 : { *(.debug_macinfo) }

177
}
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren