|
|
Если это как-то поможет:
Пакет КроссВоркс для АРМ запускает ld со следующими параметрами:
ld -X -nostdlib -e0x00000000 --omagic -EL -Tldscript.tmp -Map prjname.map -o prjname.elf, далее идет список объектных файлов
Содержимое ldscript.tmp:
MEMORY
{
Peripherals (wx) : ORIGIN = 0xe0000000, LENGTH = 0x20000000
SRAM (wx) : ORIGIN = 0x40000000, LENGTH = 0x00008000
FLASH (rx) : ORIGIN = 0x00000000, LENGTH = 0x00080000
}
SECTIONS
{
__Peripherals_segment_start__ = 0xe0000000;
__Peripherals_segment_end__ = 0x00000000;
__SRAM_segment_start__ = 0x40000000;
__SRAM_segment_end__ = 0x40008000;
__FLASH_segment_start__ = 0x00000000;
__FLASH_segment_end__ = 0x00080000;
__STACKSIZE__ = 1024;
__STACKSIZE_IRQ__ = 256;
__STACKSIZE_FIQ__ = 256;
__STACKSIZE_SVC__ = 0;
__STACKSIZE_ABT__ = 0;
__STACKSIZE_UND__ = 0;
__HEAPSIZE__ = 1024;
.vectors_ram __SRAM_segment_start__ (NOLOAD) :
{
__vectors_ram_start__ = .;
*(.vectors_ram)
. = MAX(__vectors_ram_start__ + 0x3C , .);
}
__vectors_ram_end__ = __vectors_ram_start__ + SIZEOF(.vectors_ram);
. = ASSERT(__vectors_ram_end__ >= __SRAM_segment_start__ && __vectors_ram_end__ <= (__SRAM_segment_start__ + 0x00008000) , ".vectors_ram is too large to fit in SRAM memory segment");
.vectors __FLASH_segment_start__ :
{
__vectors_start__ = .;
*(.vectors .vectors.*)
}
__vectors_end__ = __vectors_start__ + SIZEOF(.vectors);
. = ASSERT(__vectors_end__ >= __FLASH_segment_start__ && __vectors_end__ <= (__FLASH_segment_start__ + 0x00080000) , ".vectors is too large to fit in FLASH memory segment");
.init ALIGN(__vectors_end__ , 4) :
{
__init_start__ = .;
*(.init .init.*)
}
__init_end__ = __init_start__ + SIZEOF(.init);
. = ASSERT(__init_end__ >= __FLASH_segment_start__ && __init_end__ <= (__FLASH_segment_start__ + 0x00080000) , ".init is too large to fit in FLASH memory segment");
.text_load 0x00002000 (NOLOAD) :
{
__text_load_start__ = .;
*(.text_load)
}
__text_load_end__ = __text_load_start__ + SIZEOF(.text_load);
. = ASSERT(__text_load_end__ >= __FLASH_segment_start__ && __text_load_end__ <= (__FLASH_segment_start__ + 0x00080000) , ".text_load is too large to fit in FLASH memory segment");
.text 0x00002000 :
{
__text_start__ = .;
*(.text .text.* .glue_7t .glue_7 .gnu.linkonce.t.*)
}
__text_end__ = __text_start__ + SIZEOF(.text);
. = ASSERT(__text_end__ >= __FLASH_segment_start__ && __text_end__ <= (__FLASH_segment_start__ + 0x00080000) , ".text is too large to fit in FLASH memory segment");
.dtors ALIGN(__text_end__ , 4) :
{
__dtors_start__ = .;
KEEP (*(SORT(.dtors.*))) KEEP (*(.dtors))
}
__dtors_end__ = __dtors_start__ + SIZEOF(.dtors);
. = ASSERT(__dtors_end__ >= __FLASH_segment_start__ && __dtors_end__ <= (__FLASH_segment_start__ + 0x00080000) , ".dtors is too large to fit in FLASH memory segment");
.ctors ALIGN(__dtors_end__ , 4) :
{
__ctors_start__ = .;
KEEP (*(SORT(.ctors.*))) KEEP (*(.ctors))
}
__ctors_end__ = __ctors_start__ + SIZEOF(.ctors);
. = ASSERT(__ctors_end__ >= __FLASH_segment_start__ && __ctors_end__ <= (__FLASH_segment_start__ + 0x00080000) , ".ctors is too large to fit in FLASH memory segment");
.rodata ALIGN(__ctors_end__ , 4) :
{
__rodata_start__ = .;
*(.rodata .rodata.* .gnu.linkonce.r.*)
}
__rodata_end__ = __rodata_start__ + SIZEOF(.rodata);
. = ASSERT(__rodata_end__ >= __FLASH_segment_start__ && __rodata_end__ <= (__FLASH_segment_start__ + 0x00080000) , ".rodata is too large to fit in FLASH memory segment");
__fast_load_start__ = ALIGN(__rodata_end__ , 4);
.fast __vectors_ram_end__ : AT(ALIGN(__rodata_end__ , 4))
{
__fast_start__ = .;
*(.fast .fast.*)
}
__fast_end__ = __fast_start__ + SIZEOF(.fast);
. = ASSERT((__fast_load_start__ + SIZEOF(.fast)) >= __FLASH_segment_start__ && (__fast_load_start__ + SIZEOF(.fast)) <= (__FLASH_segment_start__ + 0x00080000) , ".fast is too large to fit in FLASH memory segment");
.fast_run ALIGN(__vectors_ram_end__ , 4) (NOLOAD) :
{
__fast_run_start__ = .;
. = MAX(__fast_run_start__ + SIZEOF(.fast), .);
}
__fast_run_end__ = __fast_run_start__ + SIZEOF(.fast_run);
. = ASSERT(__fast_run_end__ >= __SRAM_segment_start__ && __fast_run_end__ <= (__SRAM_segment_start__ + 0x00008000) , ".fast_run is too large to fit in SRAM memory segment");
__data_load_start__ = ALIGN(__fast_load_start__ + SIZEOF(.fast) , 4);
.data __fast_run_end__ : AT(ALIGN(__fast_load_start__ + SIZEOF(.fast) , 4))
{
__data_start__ = .;
*(.data .data.* .gnu.linkonce.d.*)
}
__data_end__ = __data_start__ + SIZEOF(.data);
. = ASSERT((__data_load_start__ + SIZEOF(.data)) >= __FLASH_segment_start__ && (__data_load_start__ + SIZEOF(.data)) <= (__FLASH_segment_start__ + 0x00080000) , ".data is too large to fit in FLASH memory segment");
.data_run ALIGN(__fast_run_end__ , 4) (NOLOAD) :
{
__data_run_start__ = .;
. = MAX(__data_run_start__ + SIZEOF(.data), .);
}
__data_run_end__ = __data_run_start__ + SIZEOF(.data_run);
. = ASSERT(__data_run_end__ >= __SRAM_segment_start__ && __data_run_end__ <= (__SRAM_segment_start__ + 0x00008000) , ".data_run is too large to fit in SRAM memory segment");
.bss ALIGN(__data_run_end__ , 4) (NOLOAD) :
{
__bss_start__ = .;
*(.bss .bss.* .gnu.linkonce.b.*) *(COMMON)
}
__bss_end__ = __bss_start__ + SIZEOF(.bss);
. = ASSERT(__bss_end__ >= __SRAM_segment_start__ && __bss_end__ <= (__SRAM_segment_start__ + 0x00008000) , ".bss is too large to fit in SRAM memory segment");
.heap ALIGN(__bss_end__ , 4) (NOLOAD) :
{
__heap_start__ = .;
*(.heap)
. = MAX(__heap_start__ + __HEAPSIZE__ , .);
}
__heap_end__ = __heap_start__ + SIZEOF(.heap);
. = ASSERT(__heap_end__ >= __SRAM_segment_start__ && __heap_end__ <= (__SRAM_segment_start__ + 0x00008000) , ".heap is too large to fit in SRAM memory segment");
.stack ALIGN(__heap_end__ , 4) (NOLOAD) :
{
__stack_start__ = .;
*(.stack)
. = MAX(__stack_start__ + __STACKSIZE__ , .);
}
__stack_end__ = __stack_start__ + SIZEOF(.stack);
. = ASSERT(__stack_end__ >= __SRAM_segment_start__ && __stack_end__ <= (__SRAM_segment_start__ + 0x00008000) , ".stack is too large to fit in SRAM memory segment");
.stack_irq ALIGN(__stack_end__ , 4) (NOLOAD) :
{
__stack_irq_start__ = .;
*(.stack_irq)
. = MAX(__stack_irq_start__ + __STACKSIZE_IRQ__ , .);
}
__stack_irq_end__ = __stack_irq_start__ + SIZEOF(.stack_irq);
. = ASSERT(__stack_irq_end__ >= __SRAM_segment_start__ && __stack_irq_end__ <= (__SRAM_segment_start__ + 0x00008000) , ".stack_irq is too large to fit in SRAM memory segment");
.stack_fiq ALIGN(__stack_irq_end__ , 4) (NOLOAD) :
{
__stack_fiq_start__ = .;
*(.stack_fiq)
. = MAX(__stack_fiq_start__ + __STACKSIZE_FIQ__ , .);
}
__stack_fiq_end__ = __stack_fiq_start__ + SIZEOF(.stack_fiq);
. = ASSERT(__stack_fiq_end__ >= __SRAM_segment_start__ && __stack_fiq_end__ <= (__SRAM_segment_start__ + 0x00008000) , ".stack_fiq is too large to fit in SRAM memory segment");
.stack_svc ALIGN(__stack_fiq_end__ , 4) (NOLOAD) :
{
__stack_svc_start__ = .;
*(.stack_svc)
. = MAX(__stack_svc_start__ + __STACKSIZE_SVC__ , .);
}
__stack_svc_end__ = __stack_svc_start__ + SIZEOF(.stack_svc);
. = ASSERT(__stack_svc_end__ >= __SRAM_segment_start__ && __stack_svc_end__ <= (__SRAM_segment_start__ + 0x00008000) , ".stack_svc is too large to fit in SRAM memory segment");
.stack_abt ALIGN(__stack_svc_end__ , 4) (NOLOAD) :
{
__stack_abt_start__ = .;
*(.stack_abt)
. = MAX(__stack_abt_start__ + __STACKSIZE_ABT__ , .);
}
__stack_abt_end__ = __stack_abt_start__ + SIZEOF(.stack_abt);
. = ASSERT(__stack_abt_end__ >= __SRAM_segment_start__ && __stack_abt_end__ <= (__SRAM_segment_start__ + 0x00008000) , ".stack_abt is too large to fit in SRAM memory segment");
.stack_und ALIGN(__stack_abt_end__ , 4) (NOLOAD) :
{
__stack_und_start__ = .;
*(.stack_und)
. = MAX(__stack_und_start__ + __STACKSIZE_UND__ , .);
}
__stack_und_end__ = __stack_und_start__ + SIZEOF(.stack_und);
. = ASSERT(__stack_und_end__ >= __SRAM_segment_start__ && __stack_und_end__ <= (__SRAM_segment_start__ + 0x00008000) , ".stack_und is too large to fit in SRAM memory segment");
__paramdata_load_start__ = 0x00001000;
.paramdata __stack_und_end__ : AT(0x00001000)
{
__paramdata_start__ = .;
*(.paramdata .paramdata.* .gnu.linkonce.d.*)
}
__paramdata_end__ = __paramdata_start__ + SIZEOF(.paramdata);
. = ASSERT((__paramdata_load_start__ + SIZEOF(.paramdata)) >= __FLASH_segment_start__ && (__paramdata_load_start__ + SIZEOF(.paramdata)) <= (__FLASH_segment_start__ + 0x00080000) , ".paramdata is too large to fit in FLASH memory segment");
.paramdata_run ALIGN(__stack_und_end__ , 4) (NOLOAD) :
{
__paramdata_run_start__ = .;
. = MAX(__paramdata_run_start__ + SIZEOF(.paramdata), .);
}
__paramdata_run_end__ = __paramdata_run_start__ + SIZEOF(.paramdata_run);
. = ASSERT(__paramdata_run_end__ >= __SRAM_segment_start__ && __paramdata_run_end__ <= (__SRAM_segment_start__ + 0x00008000) , ".paramdata_run is too large to fit in SRAM memory segment");
}
P.S. А дохтур - хам.
|
|
E-mail: 
info@telesys.ru
