From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 12845 invoked by alias); 17 Feb 2011 13:44:22 -0000 Received: (qmail 12807 invoked by uid 22791); 17 Feb 2011 13:44:20 -0000 X-SWARE-Spam-Status: No, hits=-2.6 required=5.0 tests=BAYES_00,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FROM,RCVD_IN_DNSWL_LOW,TW_XB,T_TO_NO_BRKTS_FREEMAIL X-Spam-Check-By: sourceware.org Received: from mail-iw0-f169.google.com (HELO mail-iw0-f169.google.com) (209.85.214.169) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Thu, 17 Feb 2011 13:44:15 +0000 Received: by iwc10 with SMTP id 10so2581560iwc.0 for ; Thu, 17 Feb 2011 05:44:13 -0800 (PST) MIME-Version: 1.0 Received: by 10.231.156.1 with SMTP id u1mr1606796ibw.52.1297950253479; Thu, 17 Feb 2011 05:44:13 -0800 (PST) Received: by 10.231.79.130 with HTTP; Thu, 17 Feb 2011 05:44:13 -0800 (PST) Date: Thu, 17 Feb 2011 13:44:00 -0000 Message-ID: Subject: Strange linker problem after updating binutils and gcc From: Jan Pohanka To: binutils@sourceware.org Content-Type: text/plain; charset=ISO-8859-1 X-IsSubscribed: yes Mailing-List: contact binutils-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: binutils-owner@sourceware.org X-SW-Source: 2011-02/txt/msg00208.txt.bz2 Hello, I'm using gcc with binutils in Rowley Crossworks for ARM 1.7 IDE for arm development. Unfortunately there is very old version of gcc (4.1.1) and binutils (2.17) in this IDE, so I decided to upgrade to gcc 4.4.4 and binutils 20.20.51 (I tried more versions but all are affected) Unfortunately there is a problem with linking in new version. In first try, linker generated warning "dot moved backwards before..." so I solved it with proper ordering of sections in ld script, unfortunately there is still an error because the generated elf file is wrong - some data are written in high addresses, resulting bin file has size of 500MB instead of 500kB. ld is invoked with following params: ld -X -nostdlib -ereset_handler --omagic --fatal-warnings -EL -Te:/_dev/_kamera/JR1_git/_tmp_JR615 Flash Debug/JR615 Flash Debug.1.8.23.2.h263.ld -Map _JR615 Flash Debug//JR615 Flash Debug.1.8.23.2.h263.map -u_vectors -o _JR615 Flash Debug//JR615 Flash Debug.1.8.23.2.h263.elf --start-group ... and ld script: MEMORY { UNPLACED_SECTIONS (wx) : ORIGIN = 0x100000000, LENGTH = 0 SDRAM (wx) : ORIGIN = 0x20000000, LENGTH = 0x02000000 Reserved (wx) : ORIGIN = 0x90000000, LENGTH = 0x60000000 SRAM1 (wx) : ORIGIN = 0x00300000, LENGTH = 0x00001000 SRAM0 (wx) : ORIGIN = 0x00200000, LENGTH = 0x00001000 } INTERNAL_SRAM_START_ADDRESS = 0x00200000; SDRAM_START_ADDRESS = 0x20000000; SDRAM_LENGTH = 0x02000000; SECTIONS { __SDRAM_segment_start__ = 0x20000000; __SDRAM_segment_end__ = 0x22000000; __Reserved_segment_start__ = 0x90000000; __Reserved_segment_end__ = 0xf0000000; __SRAM1_segment_start__ = 0x00300000; __SRAM1_segment_end__ = 0x00301000; __SRAM0_segment_start__ = 0x00200000; __SRAM0_segment_end__ = 0x00201000; __STACKSIZE__ = 512000; __STACKSIZE_IRQ__ = 128000; __STACKSIZE_FIQ__ = 4096; __STACKSIZE_SVC__ = 4096; __STACKSIZE_ABT__ = 4096; __STACKSIZE_UND__ = 4096; __HEAPSIZE__ = 4000000; __vectors_ram_load_start__ = 0x00200000; .vectors_ram 0x00200000 (NOLOAD) : { __vectors_ram_start__ = .; *(.vectors_ram) . = MAX(__vectors_ram_start__ + 0x3C , .); } __vectors_ram_end__ = __vectors_ram_start__ + SIZEOF(.vectors_ram); . = ASSERT(__vectors_ram_end__ >= __SRAM0_segment_start__ && __vectors_ram_end__ <= (__SRAM0_segment_start__ + 0x00001000) , "error: .vectors_ram is too large to fit in SRAM0 memory segment"); __sram_noninit_data_load_start__ = 0x00200040; .sram_noninit_data 0x00200040 (NOLOAD) : { __sram_noninit_data_start__ = .; *(.sram_noninit_data) . = MAX(__sram_noninit_data_start__ + 0xbb8 , .); } __sram_noninit_data_end__ = __sram_noninit_data_start__ + SIZEOF(.sram_noninit_data); . = ASSERT(__sram_noninit_data_end__ >= __SRAM0_segment_start__ && __sram_noninit_data_end__ <= (__SRAM0_segment_start__ + 0x00001000) , "error: .sram_noninit_data is too large to fit in SRAM0 memory segment"); . = ASSERT(__vectors_ram_end__ <= __sram_noninit_data_start__ , "error: section .vectors_ram overlaps absolute placed section .sram_noninit_data"); __reserved_debug_handler_load_start__ = 0x00200c00; .reserved_debug_handler 0x00200c00 (NOLOAD) : { __reserved_debug_handler_start__ = .; *(.reserved_debug_handler) . = MAX(__reserved_debug_handler_start__ + 0x400 , .); } __reserved_debug_handler_end__ = __reserved_debug_handler_start__ + SIZEOF(.reserved_debug_handler); __SRAM0_segment_used_end__ = 0x00200c00 + SIZEOF(.reserved_debug_handler); . = ASSERT(__reserved_debug_handler_end__ >= __SRAM0_segment_start__ && __reserved_debug_handler_end__ <= (__SRAM0_segment_start__ + 0x00001000) , "error: .reserved_debug_handler is too large to fit in SRAM0 memory segment"); . = ASSERT(__sram_noninit_data_end__ <= __reserved_debug_handler_start__ , "error: section .sram_noninit_data overlaps absolute placed section .reserved_debug_handler"); __reserved_mmu_load_start__ = ALIGN(__SDRAM_segment_start__ , 4); .reserved_mmu ALIGN(__SDRAM_segment_start__ , 4) (NOLOAD) : { __reserved_mmu_start__ = .; *(.reserved_mmu) . = ALIGN(MAX(__reserved_mmu_start__ + 0x4000 , .), 4); } __reserved_mmu_end__ = __reserved_mmu_start__ + SIZEOF(.reserved_mmu); . = ASSERT(__reserved_mmu_end__ >= __SDRAM_segment_start__ && __reserved_mmu_end__ <= (__SDRAM_segment_start__ + 0x02000000) , "error: .reserved_mmu is too large to fit in SDRAM memory segment"); __boot_load_start__ = __reserved_mmu_end__; .boot __reserved_mmu_end__ : { __boot_start__ = .; *(.boot) . = MAX(__boot_start__ + 0x80e8 , .); } __boot_end__ = __boot_start__ + SIZEOF(.boot); . = ASSERT(__boot_end__ >= __SDRAM_segment_start__ && __boot_end__ <= (__SDRAM_segment_start__ + 0x02000000) , "error: .boot is too large to fit in SDRAM memory segment"); __vectors_load_start__ = ALIGN(__boot_end__ , 4); .vectors ALIGN(__boot_end__ , 4) : { __vectors_start__ = .; *(.vectors .vectors.*) . = ALIGN(MAX(__vectors_start__ + 0x108 , .), 4); } __vectors_end__ = __vectors_start__ + SIZEOF(.vectors); . = ASSERT(__vectors_end__ >= __SDRAM_segment_start__ && __vectors_end__ <= (__SDRAM_segment_start__ + 0x02000000) , "error: .vectors is too large to fit in SDRAM memory segment"); __localization_load_start__ = __vectors_end__; .localization __vectors_end__ : { __localization_start__ = .; *(.localization) . = MAX(__localization_start__ + 0x40f8 , .); } __localization_end__ = __localization_start__ + SIZEOF(.localization); . = ASSERT(__localization_end__ >= __SDRAM_segment_start__ && __localization_end__ <= (__SDRAM_segment_start__ + 0x02000000) , "error: .localization is too large to fit in SDRAM memory segment"); __init_load_start__ = ALIGN(__localization_end__ , 4); .init ALIGN(__localization_end__ , 4) : { __init_start__ = .; *(.init .init.*) } __init_end__ = __init_start__ + SIZEOF(.init); . = ASSERT(__init_end__ >= __SDRAM_segment_start__ && __init_end__ <= (__SDRAM_segment_start__ + 0x02000000) , "error: .init is too large to fit in SDRAM memory segment"); __text_load_start__ = ALIGN(__init_end__ , 4); .text ALIGN(__init_end__ , 4) : { __text_start__ = .; *(.text .text.* .glue_7t .glue_7 .gnu.linkonce.t.*) } __text_end__ = __text_start__ + SIZEOF(.text); . = ASSERT(__text_end__ >= __SDRAM_segment_start__ && __text_end__ <= (__SDRAM_segment_start__ + 0x02000000) , "error: .text is too large to fit in SDRAM memory segment"); __dtors_load_start__ = ALIGN(__text_end__ , 4); .dtors ALIGN(__text_end__ , 4) : { __dtors_start__ = .; KEEP (*(SORT(.dtors.*))) KEEP (*(.dtors)) } __dtors_end__ = __dtors_start__ + SIZEOF(.dtors); . = ASSERT(__dtors_end__ >= __SDRAM_segment_start__ && __dtors_end__ <= (__SDRAM_segment_start__ + 0x02000000) , "error: .dtors is too large to fit in SDRAM memory segment"); __ctors_load_start__ = ALIGN(__dtors_end__ , 4); .ctors ALIGN(__dtors_end__ , 4) : { __ctors_start__ = .; KEEP (*(SORT(.ctors.*))) KEEP (*(.ctors)) } __ctors_end__ = __ctors_start__ + SIZEOF(.ctors); . = ASSERT(__ctors_end__ >= __SDRAM_segment_start__ && __ctors_end__ <= (__SDRAM_segment_start__ + 0x02000000) , "error: .ctors is too large to fit in SDRAM memory segment"); __fast_load_start__ = ALIGN(__ctors_end__ , 4); .fast ALIGN(__SRAM1_segment_start__ , 4) : AT(ALIGN(__ctors_end__ , 4)) { __fast_start__ = .; *(.fast .fast.*) } __fast_end__ = __fast_start__ + SIZEOF(.fast); __fast_load_end__ = __fast_load_start__ + SIZEOF(.fast); . = ASSERT((__fast_load_start__ + SIZEOF(.fast)) >= __SDRAM_segment_start__ && (__fast_load_start__ + SIZEOF(.fast)) <= (__SDRAM_segment_start__ + 0x02000000) , "error: .fast is too large to fit in SDRAM memory segment"); .fast_run ALIGN(__SRAM1_segment_start__ , 4) (NOLOAD) : { __fast_run_start__ = .; . = MAX(__fast_run_start__ + SIZEOF(.fast), .); } __fast_run_end__ = __fast_run_start__ + SIZEOF(.fast_run); __SRAM1_segment_used_end__ = ALIGN(__SRAM1_segment_start__ , 4) + SIZEOF(.fast_run); . = ASSERT(__fast_run_end__ >= __SRAM1_segment_start__ && __fast_run_end__ <= (__SRAM1_segment_start__ + 0x00001000) , "error: .fast_run is too large to fit in SRAM1 memory segment"); __data_load_start__ = ALIGN(__fast_load_start__ + SIZEOF(.fast) , 4); .data ALIGN(__fast_load_start__ + SIZEOF(.fast) , 4) : { __data_start__ = .; *(.data .data.* .gnu.linkonce.d.*) } __data_end__ = __data_start__ + SIZEOF(.data); . = ASSERT(__data_end__ >= __SDRAM_segment_start__ && __data_end__ <= (__SDRAM_segment_start__ + 0x02000000) , "error: .data is too large to fit in SDRAM memory segment"); __rodata_load_start__ = ALIGN(__data_end__ , 4); .rodata ALIGN(__data_end__ , 4) : { __rodata_start__ = .; *(.rodata .rodata.* .gnu.linkonce.r.*) } __rodata_end__ = __rodata_start__ + SIZEOF(.rodata); . = ASSERT(__rodata_end__ >= __SDRAM_segment_start__ && __rodata_end__ <= (__SDRAM_segment_start__ + 0x02000000) , "error: .rodata is too large to fit in SDRAM memory segment"); __bss_load_start__ = ALIGN(__rodata_end__ , 4); .bss ALIGN(__rodata_end__ , 4) (NOLOAD) : { __bss_start__ = .; *(.bss .bss.* .gnu.linkonce.b.*) *(COMMON) } __bss_end__ = __bss_start__ + SIZEOF(.bss); . = ASSERT(__bss_end__ >= __SDRAM_segment_start__ && __bss_end__ <= (__SDRAM_segment_start__ + 0x02000000) , "error: .bss is too large to fit in SDRAM memory segment"); __text_user_load_start__ = ALIGN(__bss_end__ , 4); .text_user ALIGN(__bss_end__ , 4) (NOLOAD) : { __text_user_start__ = .; *(.text_user) } __text_user_end__ = __text_user_start__ + SIZEOF(.text_user); . = ASSERT(__text_user_end__ >= __SDRAM_segment_start__ && __text_user_end__ <= (__SDRAM_segment_start__ + 0x02000000) , "error: .text_user is too large to fit in SDRAM memory segment"); __non_init_load_start__ = ALIGN(__text_user_end__ , 4); .non_init ALIGN(__text_user_end__ , 4) (NOLOAD) : { __non_init_start__ = .; *(.non_init .non_init.*) } __non_init_end__ = __non_init_start__ + SIZEOF(.non_init); . = ASSERT(__non_init_end__ >= __SDRAM_segment_start__ && __non_init_end__ <= (__SDRAM_segment_start__ + 0x02000000) , "error: .non_init is too large to fit in SDRAM memory segment"); __heap_load_start__ = ALIGN(__non_init_end__ , 4); .heap ALIGN(__non_init_end__ , 4) (NOLOAD) : { __heap_start__ = .; *(.heap) . = ALIGN(MAX(__heap_start__ + __HEAPSIZE__ , .), 4); } __heap_end__ = __heap_start__ + SIZEOF(.heap); . = ASSERT(__heap_end__ >= __SDRAM_segment_start__ && __heap_end__ <= (__SDRAM_segment_start__ + 0x02000000) , "error: .heap is too large to fit in SDRAM memory segment"); __stack_load_start__ = ALIGN(__heap_end__ , 4); .stack ALIGN(__heap_end__ , 4) (NOLOAD) : { __stack_start__ = .; *(.stack) . = ALIGN(MAX(__stack_start__ + __STACKSIZE__ , .), 4); } __stack_end__ = __stack_start__ + SIZEOF(.stack); . = ASSERT(__stack_end__ >= __SDRAM_segment_start__ && __stack_end__ <= (__SDRAM_segment_start__ + 0x02000000) , "error: .stack is too large to fit in SDRAM memory segment"); __stack_irq_load_start__ = ALIGN(__stack_end__ , 4); .stack_irq ALIGN(__stack_end__ , 4) (NOLOAD) : { __stack_irq_start__ = .; *(.stack_irq) . = ALIGN(MAX(__stack_irq_start__ + __STACKSIZE_IRQ__ , .), 4); } __stack_irq_end__ = __stack_irq_start__ + SIZEOF(.stack_irq); . = ASSERT(__stack_irq_end__ >= __SDRAM_segment_start__ && __stack_irq_end__ <= (__SDRAM_segment_start__ + 0x02000000) , "error: .stack_irq is too large to fit in SDRAM memory segment"); __stack_fiq_load_start__ = ALIGN(__stack_irq_end__ , 4); .stack_fiq ALIGN(__stack_irq_end__ , 4) (NOLOAD) : { __stack_fiq_start__ = .; *(.stack_fiq) . = ALIGN(MAX(__stack_fiq_start__ + __STACKSIZE_FIQ__ , .), 4); } __stack_fiq_end__ = __stack_fiq_start__ + SIZEOF(.stack_fiq); . = ASSERT(__stack_fiq_end__ >= __SDRAM_segment_start__ && __stack_fiq_end__ <= (__SDRAM_segment_start__ + 0x02000000) , "error: .stack_fiq is too large to fit in SDRAM memory segment"); __stack_svc_load_start__ = ALIGN(__stack_fiq_end__ , 4); .stack_svc ALIGN(__stack_fiq_end__ , 4) (NOLOAD) : { __stack_svc_start__ = .; *(.stack_svc) . = ALIGN(MAX(__stack_svc_start__ + __STACKSIZE_SVC__ , .), 4); } __stack_svc_end__ = __stack_svc_start__ + SIZEOF(.stack_svc); . = ASSERT(__stack_svc_end__ >= __SDRAM_segment_start__ && __stack_svc_end__ <= (__SDRAM_segment_start__ + 0x02000000) , "error: .stack_svc is too large to fit in SDRAM memory segment"); __stack_abt_load_start__ = ALIGN(__stack_svc_end__ , 4); .stack_abt ALIGN(__stack_svc_end__ , 4) (NOLOAD) : { __stack_abt_start__ = .; *(.stack_abt) . = ALIGN(MAX(__stack_abt_start__ + __STACKSIZE_ABT__ , .), 4); } __stack_abt_end__ = __stack_abt_start__ + SIZEOF(.stack_abt); . = ASSERT(__stack_abt_end__ >= __SDRAM_segment_start__ && __stack_abt_end__ <= (__SDRAM_segment_start__ + 0x02000000) , "error: .stack_abt is too large to fit in SDRAM memory segment"); __stack_und_load_start__ = ALIGN(__stack_abt_end__ , 4); .stack_und ALIGN(__stack_abt_end__ , 4) (NOLOAD) : { __stack_und_start__ = .; *(.stack_und) . = ALIGN(MAX(__stack_und_start__ + __STACKSIZE_UND__ , .), 4); } __stack_und_end__ = __stack_und_start__ + SIZEOF(.stack_und); . = ASSERT(__stack_und_end__ >= __SDRAM_segment_start__ && __stack_und_end__ <= (__SDRAM_segment_start__ + 0x02000000) , "error: .stack_und is too large to fit in SDRAM memory segment"); __exceptions_log_load_start__ = 0x21eff000; .exceptions_log 0x21eff000 (NOLOAD) : { __exceptions_log_start__ = .; *(.exceptions_log) . = MAX(__exceptions_log_start__ + 0x1000 , .); } __exceptions_log_end__ = __exceptions_log_start__ + SIZEOF(.exceptions_log); . = ASSERT(__exceptions_log_end__ >= __SDRAM_segment_start__ && __exceptions_log_end__ <= (__SDRAM_segment_start__ + 0x02000000) , "error: .exceptions_log is too large to fit in SDRAM memory segment"); . = ASSERT(__stack_und_end__ <= __exceptions_log_start__ , "error: section .stack_und overlaps absolute placed section .exceptions_log"); __nocache_load_start__ = 0x21f00000; .nocache 0x21f00000 (NOLOAD) : { __nocache_start__ = .; *(.nocache) } __nocache_end__ = __nocache_start__ + SIZEOF(.nocache); __SDRAM_segment_used_end__ = 0x21f00000 + SIZEOF(.nocache); . = ASSERT(__nocache_end__ >= __SDRAM_segment_start__ && __nocache_end__ <= (__SDRAM_segment_start__ + 0x02000000) , "error: .nocache is too large to fit in SDRAM memory segment"); . = ASSERT(__exceptions_log_end__ <= __nocache_start__ , "error: section .exceptions_log overlaps absolute placed section .nocache"); } Could anyone please give me any hint how to solve this problem? best regards Jan