On 12.03.13 12:53, Thomas, George wrote:
> When I checked the linker scripts, all __flashN's are going into the same
> location.
...
>
> Are there any issues in fixing these in the linker scripts ?
No, handling of __flashN's in a highly flexible and user-friendly manner
has been available for some months now, although separately. It was
initially provided as a linker script which can be used with your
existing toolchain version, by means of "-T". (The latest (from
December) is attached.)
The fully integrated version, which introduces architecture-optimised
linker script auto-selection to the AVR toolchain, is attached to:
http://www.mail-archive.com/avr-gcc-list@nongnu.org/msg08226.html
> Also saw some discussion in the list regarding the same.
> http://lists.nongnu.org/archive/html/avr-gcc-list/2012-12/msg00038.html
> but could not find any patches in trunk.
Please see msg08226.html. We were only waiting on Eric to say whether
he'd like anything tweaked. (A real user is even better. ;-)
If there's anything you need, either to just have a go with the script
alone, using -T, or to patch the ld source code, to have your toolchain
automatically switch in the augmented linker script for avr6 (but
continue to use the old script for lower architectures), then just yell
out. (On-list, or off, as preferred.)
OK, here is the start of msg08226.html again, for its brief description
of how the old (low-architecture) linker script can now co-exist with
the enhanced script for higher architectures, fully integrated in the
toolchain. (The user then need not worry about such details.)
On 22.01.13 22:51, Erik Christiansen wrote:
> On 19.12.12 17:53, Weddington, Eric wrote:
> > Hi Erik,
> >
> > So far, I like how you're describing it below.
> >
> > Did I miss the actual linker script that you're proposing? Do you have a
> > patch?
> >
> > Eric
>
> As intimated upthread, here are three simple patches which now
> incorporate the avr6 script into binutils as a second script template,
> and add tweaks to activate the binutils capacity for multiple templates.
> This now autogenerates the full set of avr6 linker scripts in binutils,
> from the additional template.
>
> As a consequence, users of other avr architectures will continue to use
> the old linker script, and will remain blissfully unaffected by the new
> features in the more advanced script.
>
> If we want the features for any additional architectures, then the new
> linker script can be switched in where and when needed, with
> customisation, if needed.
>
> Clearly, the toolchain is not limited to one linker script template, as
> had been feared.
>
> I have done regression testing (repeating the original test set), but
> some independent testing at some stage would do no harm.
Please run "avr-objdump -h" on your elf file to see what's ging into
each FlashN, and how .text is wrapped around that, without wasted space.
(.lowtext is the stuff that is required to be in low memory, while
.hightext is that which is allowed to be shuffled up, without penalty.)
Any questions you ask will help motivate me to write some doco. :-)
Eric, the ability to fully customise an individual linker script template
for each AVR architecture is a powerful new feature for our target,
which uses existing ld code features to cut the Gordian knot of trying
to handle avr2 and avr6 with one linker script, as was done in the
previous millenium. (See msg08226.html)
Erik
--
"You know, it's at times like this when I'm trapped in a Vogon airlock
with a man from Betelgeuse and about to die of asphyxiation in deep
space that I really wish I'd listened to what my mother told me when I
was young!"
"Why, what did she tell you?"
"I don't know, I didn't listen!"
- Douglas Adams, "Hitchhiker's Guide to the Galaxy"
/* Default linker script, for normal executables */
OUTPUT_FORMAT("elf32-avr","elf32-avr","elf32-avr")
OUTPUT_ARCH(avr:6)
MEMORY
{
text (rx) : ORIGIN = 0, LENGTH = 1024K
data (rw!x) : ORIGIN = 0x800200, LENGTH = 0xfe00
eeprom (rw!x) : ORIGIN = 0x810000, LENGTH = 64K
fuse (rw!x) : ORIGIN = 0x820000, LENGTH = 1K
lock (rw!x) : ORIGIN = 0x830000, LENGTH = 1K
signature (rw!x) : ORIGIN = 0x840000, LENGTH = 1K
}
SECTIONS
{
/* Read-only sections, merged into text segment: */
.hash : { *(.hash) }
.dynsym : { *(.dynsym) }
.dynstr : { *(.dynstr) }
.gnu.version : { *(.gnu.version) }
.gnu.version_d : { *(.gnu.version_d) }
.gnu.version_r : { *(.gnu.version_r) }
.rel.init : { *(.rel.init) }
.rela.init : { *(.rela.init) }
.rel.text :
{
*(.rel.text)
*(.rel.text.*)
*(.rel.gnu.linkonce.t*)
}
.rela.text :
{
*(.rela.text)
*(.rela.text.*)
*(.rela.gnu.linkonce.t*)
}
.rel.fini : { *(.rel.fini) }
.rela.fini : { *(.rela.fini) }
.rel.rodata :
{
*(.rel.rodata)
*(.rel.rodata.*)
*(.rel.gnu.linkonce.r*)
}
.rela.rodata :
{
*(.rela.rodata)
*(.rela.rodata.*)
*(.rela.gnu.linkonce.r*)
}
.rel.data :
{
*(.rel.data)
*(.rel.data.*)
*(.rel.gnu.linkonce.d*)
}
.rela.data :
{
*(.rela.data)
*(.rela.data.*)
*(.rela.gnu.linkonce.d*)
}
.rel.ctors : { *(.rel.ctors) }
.rela.ctors : { *(.rela.ctors) }
.rel.dtors : { *(.rel.dtors) }
.rela.dtors : { *(.rela.dtors) }
.rel.got : { *(.rel.got) }
.rela.got : { *(.rela.got) }
.rel.bss : { *(.rel.bss) }
.rela.bss : { *(.rela.bss) }
.rel.plt : { *(.rel.plt) }
.rela.plt : { *(.rela.plt) }
/* Internal text space or external memory. */
.lowtext :
{
*(.vectors)
KEEP(*(.vectors))
/* For data that needs to reside in the lower 64k of progmem. */
*(.progmem.gcc*)
. = ALIGN(2);
__trampolines_start = . ;
/* The jump trampolines for the 16-bit limited relocs will reside here. */
*(.trampolines)
*(.trampolines*)
__trampolines_end = . ;
/* For future tablejump instruction arrays for 3 byte pc devices.
We don't relax jump/call instructions within these sections. */
*(.jumptables)
*(.jumptables*)
/* For code that needs to reside in the lower 128k progmem. */
*(.lowtext)
*(.lowtext*)
__ctors_start = . ;
*(.ctors)
__ctors_end = . ;
__dtors_start = . ;
*(.dtors)
__dtors_end = . ;
KEEP(SORT(*)(.ctors))
KEEP(SORT(*)(.dtors))
*(.progmem.data*) /* Explicitly page 0 input sections */
_elowtext = . ;
x = ASSERT (. <= 0x20000, "Error: .lowtext (128KiB limit) overflow. Try
shrinking .progmem?") ;
} > text
.flash1 0x10000 :
{ *(.progmem1.data*) /* Page 1 */
} > text
.flash2 0x20000 :
{ *(.progmem2.data*) /* Page 2 */
} > text
.flash3 0x30000 :
{ *(.progmem3.data*) /* Page 3 */
} > text
.flash4 0x40000 :
{ *(.progmem4.data*) /* Page 4 */
} > text
.flash5 0x50000 :
{ *(.progmem5.data*) /* Page 5 */
} > text
.hightext :
{
/* The following is OK to follow preceding sections
at any even byte address, on any page. */
. = ALIGN(2) ;
*(.init0) /* Start here after reset. */
KEEP (*(.init0))
*(.init1)
KEEP (*(.init1))
*(.init2) /* Clear __zero_reg__, set up stack pointer. */
KEEP (*(.init2))
*(.init3)
KEEP (*(.init3))
*(.init4) /* Initialize data and BSS. */
KEEP (*(.init4))
*(.init5)
KEEP (*(.init5))
*(.init6) /* C++ constructors. */
KEEP (*(.init6))
*(.init7)
KEEP (*(.init7))
*(.init8)
KEEP (*(.init8))
*(.init9) /* Call main(). */
KEEP (*(.init9))
*(.text)
. = ALIGN(2);
*(.text.*)
. = ALIGN(2);
*(.fini9) /* _exit() starts here. */
KEEP (*(.fini9))
*(.fini8)
KEEP (*(.fini8))
*(.fini7)
KEEP (*(.fini7))
*(.fini6) /* C++ destructors. */
KEEP (*(.fini6))
*(.fini5)
KEEP (*(.fini5))
*(.fini4)
KEEP (*(.fini4))
*(.fini3)
KEEP (*(.fini3))
*(.fini2)
KEEP (*(.fini2))
*(.fini1)
KEEP (*(.fini1))
*(.fini0) /* Infinite loop after program termination. */
KEEP (*(.fini0))
_etext = . ;
} > text
.data : AT (_etext)
{
PROVIDE (__data_start = .) ;
/* --gc-sections will delete empty .data. This leads to wrong start
addresses for subsequent sections because -Tdata= from the command
line will have no effect, see PR13697. Thus, keep .data */
KEEP (*(.data))
*(.data*)
*(.rodata) /* We need to include .rodata here if gcc is used */
*(.rodata*) /* with -fdata-sections. */
*(.gnu.linkonce.d*)
. = ALIGN(2);
_edata = . ;
PROVIDE (__data_end = .) ;
} > data
.bss : AT (ADDR (.bss))
{
PROVIDE (__bss_start = .) ;
*(.bss)
*(.bss*)
*(COMMON)
PROVIDE (__bss_end = .) ;
} > data
__data_load_start = LOADADDR(.data);
__data_load_end = __data_load_start + SIZEOF(.data);
/* Global data not cleared after reset. */
.noinit :
{
PROVIDE (__noinit_start = .) ;
*(.noinit*)
PROVIDE (__noinit_end = .) ;
_end = . ;
PROVIDE (__heap_start = .) ;
} > data
.eeprom :
{
*(.eeprom*)
__eeprom_end = . ;
} > eeprom
.fuse :
{
KEEP(*(.fuse))
KEEP(*(.lfuse))
KEEP(*(.hfuse))
KEEP(*(.efuse))
} > fuse
.lock :
{
KEEP(*(.lock*))
} > lock
.signature :
{
KEEP(*(.signature*))
} > signature
x = ASSERT (SIZEOF(.flash1) <= 0x10000, "Error: __flash1 (64KiB limit)
overflow. Need to shrink it.") ;
x = ASSERT (SIZEOF(.flash2) <= 0x10000, "Error: __flash2 (64KiB limit)
overflow. Need to shrink it.") ;
x = ASSERT (SIZEOF(.flash3) <= 0x10000, "Error: __flash3 (64KiB limit)
overflow. Need to shrink it.") ;
x = ASSERT (SIZEOF(.flash4) <= 0x10000, "Error: __flash4 (64KiB limit)
overflow. Need to shrink it.") ;
x = ASSERT (SIZEOF(.flash5) <= 0x10000, "Error: __flash5 (64KiB limit)
overflow. Need to shrink it.") ;
/* Stabs debugging sections. */
.stab 0 : { *(.stab) }
.stabstr 0 : { *(.stabstr) }
.stab.excl 0 : { *(.stab.excl) }
.stab.exclstr 0 : { *(.stab.exclstr) }
.stab.index 0 : { *(.stab.index) }
.stab.indexstr 0 : { *(.stab.indexstr) }
.comment 0 : { *(.comment) }
/* DWARF debug sections.
Symbols in the DWARF debugging sections are relative to the beginning
of the section so we begin them at 0. */
/* DWARF 1 */
.debug 0 : { *(.debug) }
.line 0 : { *(.line) }
/* GNU DWARF 1 extensions */
.debug_srcinfo 0 : { *(.debug_srcinfo) }
.debug_sfnames 0 : { *(.debug_sfnames) }
/* DWARF 1.1 and DWARF 2 */
.debug_aranges 0 : { *(.debug_aranges) }
.debug_pubnames 0 : { *(.debug_pubnames) }
/* DWARF 2 */
.debug_info 0 : { *(.debug_info) *(.gnu.linkonce.wi.*) }
.debug_abbrev 0 : { *(.debug_abbrev) }
.debug_line 0 : { *(.debug_line) }
.debug_frame 0 : { *(.debug_frame) }
.debug_str 0 : { *(.debug_str) }
.debug_loc 0 : { *(.debug_loc) }
.debug_macinfo 0 : { *(.debug_macinfo) }
/* DWARF 3 */
.debug_pubtypes 0 : { *(.debug_pubtypes) }
.debug_ranges 0 : { *(.debug_ranges) }
/* DWARF Extension. */
.debug_macro 0 : { *(.debug_macro) }
}
_______________________________________________
AVR-GCC-list mailing list
AVR-GCC-list@nongnu.org
https://lists.nongnu.org/mailman/listinfo/avr-gcc-list
