From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 1022 invoked by alias); 21 Feb 2011 07:33:47 -0000 Received: (qmail 1012 invoked by uid 22791); 21 Feb 2011 07:33:45 -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-iy0-f169.google.com (HELO mail-iy0-f169.google.com) (209.85.210.169) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Mon, 21 Feb 2011 07:33:38 +0000 Received: by iyf13 with SMTP id 13so2425230iyf.0 for ; Sun, 20 Feb 2011 23:33:36 -0800 (PST) MIME-Version: 1.0 Received: by 10.231.199.12 with SMTP id eq12mr958331ibb.2.1298273615813; Sun, 20 Feb 2011 23:33:35 -0800 (PST) Received: by 10.231.79.130 with HTTP; Sun, 20 Feb 2011 23:33:35 -0800 (PST) In-Reply-To: References: Date: Mon, 21 Feb 2011 07:33:00 -0000 Message-ID: Subject: Re: Strange linker problem after updating binutils and gcc From: Jan Pohanka To: binutils@sourceware.org Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable 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/msg00250.txt.bz2 No clue? rgds Jan 2011/2/17 Jan Pohanka : > 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 > { > =A0UNPLACED_SECTIONS (wx) : ORIGIN =3D 0x100000000, LENGTH =3D 0 > =A0SDRAM (wx) : ORIGIN =3D 0x20000000, LENGTH =3D 0x02000000 > =A0Reserved (wx) : ORIGIN =3D 0x90000000, LENGTH =3D 0x60000000 > =A0SRAM1 (wx) : ORIGIN =3D 0x00300000, LENGTH =3D 0x00001000 > =A0SRAM0 (wx) : ORIGIN =3D 0x00200000, LENGTH =3D 0x00001000 > } > > INTERNAL_SRAM_START_ADDRESS =3D 0x00200000; > SDRAM_START_ADDRESS =3D 0x20000000; > SDRAM_LENGTH =3D 0x02000000; > > SECTIONS > { > =A0__SDRAM_segment_start__ =3D 0x20000000; > =A0__SDRAM_segment_end__ =3D 0x22000000; > =A0__Reserved_segment_start__ =3D 0x90000000; > =A0__Reserved_segment_end__ =3D 0xf0000000; > =A0__SRAM1_segment_start__ =3D 0x00300000; > =A0__SRAM1_segment_end__ =3D 0x00301000; > =A0__SRAM0_segment_start__ =3D 0x00200000; > =A0__SRAM0_segment_end__ =3D 0x00201000; > > =A0__STACKSIZE__ =3D 512000; > =A0__STACKSIZE_IRQ__ =3D 128000; > =A0__STACKSIZE_FIQ__ =3D 4096; > =A0__STACKSIZE_SVC__ =3D 4096; > =A0__STACKSIZE_ABT__ =3D 4096; > =A0__STACKSIZE_UND__ =3D 4096; > =A0__HEAPSIZE__ =3D 4000000; > > =A0__vectors_ram_load_start__ =3D 0x00200000; > =A0.vectors_ram 0x00200000 (NOLOAD) : > =A0{ > =A0 =A0__vectors_ram_start__ =3D .; > =A0 =A0*(.vectors_ram) > =A0 =A0. =3D MAX(__vectors_ram_start__ + 0x3C , .); > =A0} > =A0__vectors_ram_end__ =3D __vectors_ram_start__ + SIZEOF(.vectors_ram); > > =A0. =3D ASSERT(__vectors_ram_end__ >=3D __SRAM0_segment_start__ && > __vectors_ram_end__ <=3D (__SRAM0_segment_start__ + 0x00001000) , > "error: .vectors_ram is too large to fit in SRAM0 memory segment"); > > =A0__sram_noninit_data_load_start__ =3D 0x00200040; > =A0.sram_noninit_data 0x00200040 (NOLOAD) : > =A0{ > =A0 =A0__sram_noninit_data_start__ =3D .; > =A0 =A0*(.sram_noninit_data) > =A0 =A0. =3D MAX(__sram_noninit_data_start__ + 0xbb8 , .); > =A0} > =A0__sram_noninit_data_end__ =3D __sram_noninit_data_start__ + > SIZEOF(.sram_noninit_data); > > =A0. =3D ASSERT(__sram_noninit_data_end__ >=3D __SRAM0_segment_start__ && > __sram_noninit_data_end__ <=3D (__SRAM0_segment_start__ + 0x00001000) , > "error: .sram_noninit_data is too large to fit in SRAM0 memory > segment"); > > =A0. =3D ASSERT(__vectors_ram_end__ <=3D __sram_noninit_data_start__ , > "error: section .vectors_ram overlaps absolute placed section > .sram_noninit_data"); > > =A0__reserved_debug_handler_load_start__ =3D 0x00200c00; > =A0.reserved_debug_handler 0x00200c00 (NOLOAD) : > =A0{ > =A0 =A0__reserved_debug_handler_start__ =3D .; > =A0 =A0*(.reserved_debug_handler) > =A0 =A0. =3D MAX(__reserved_debug_handler_start__ + 0x400 , .); > =A0} > =A0__reserved_debug_handler_end__ =3D __reserved_debug_handler_start__ + > SIZEOF(.reserved_debug_handler); > > =A0__SRAM0_segment_used_end__ =3D 0x00200c00 + SIZEOF(.reserved_debug_han= dler); > > =A0. =3D ASSERT(__reserved_debug_handler_end__ >=3D __SRAM0_segment_start= __ > && __reserved_debug_handler_end__ <=3D (__SRAM0_segment_start__ + > 0x00001000) , "error: .reserved_debug_handler is too large to fit in > SRAM0 memory segment"); > > =A0. =3D ASSERT(__sram_noninit_data_end__ <=3D > __reserved_debug_handler_start__ , "error: section .sram_noninit_data > overlaps absolute placed section .reserved_debug_handler"); > > =A0__reserved_mmu_load_start__ =3D ALIGN(__SDRAM_segment_start__ , 4); > =A0.reserved_mmu ALIGN(__SDRAM_segment_start__ , 4) (NOLOAD) : > =A0{ > =A0 =A0__reserved_mmu_start__ =3D .; > =A0 =A0*(.reserved_mmu) > =A0 =A0. =3D ALIGN(MAX(__reserved_mmu_start__ + 0x4000 , .), 4); > =A0} > =A0__reserved_mmu_end__ =3D __reserved_mmu_start__ + SIZEOF(.reserved_mmu= ); > > =A0. =3D ASSERT(__reserved_mmu_end__ >=3D __SDRAM_segment_start__ && > __reserved_mmu_end__ <=3D (__SDRAM_segment_start__ + 0x02000000) , > "error: .reserved_mmu is too large to fit in SDRAM memory segment"); > > =A0__boot_load_start__ =3D __reserved_mmu_end__; > =A0.boot __reserved_mmu_end__ : > =A0{ > =A0 =A0__boot_start__ =3D .; > =A0 =A0*(.boot) > =A0 =A0. =3D MAX(__boot_start__ + 0x80e8 , .); > =A0} > =A0__boot_end__ =3D __boot_start__ + SIZEOF(.boot); > > =A0. =3D ASSERT(__boot_end__ >=3D __SDRAM_segment_start__ && __boot_end__ > <=3D (__SDRAM_segment_start__ + 0x02000000) , "error: .boot is too large > to fit in SDRAM memory segment"); > > =A0__vectors_load_start__ =3D ALIGN(__boot_end__ , 4); > =A0.vectors ALIGN(__boot_end__ , 4) : > =A0{ > =A0 =A0__vectors_start__ =3D .; > =A0 =A0*(.vectors .vectors.*) > =A0 =A0. =3D ALIGN(MAX(__vectors_start__ + 0x108 , .), 4); > =A0} > =A0__vectors_end__ =3D __vectors_start__ + SIZEOF(.vectors); > > =A0. =3D ASSERT(__vectors_end__ >=3D __SDRAM_segment_start__ && > __vectors_end__ <=3D (__SDRAM_segment_start__ + 0x02000000) , "error: > .vectors is too large to fit in SDRAM memory segment"); > > =A0__localization_load_start__ =3D __vectors_end__; > =A0.localization __vectors_end__ : > =A0{ > =A0 =A0__localization_start__ =3D .; > =A0 =A0*(.localization) > =A0 =A0. =3D MAX(__localization_start__ + 0x40f8 , .); > =A0} > =A0__localization_end__ =3D __localization_start__ + SIZEOF(.localization= ); > > =A0. =3D ASSERT(__localization_end__ >=3D __SDRAM_segment_start__ && > __localization_end__ <=3D (__SDRAM_segment_start__ + 0x02000000) , > "error: .localization is too large to fit in SDRAM memory segment"); > > =A0__init_load_start__ =3D ALIGN(__localization_end__ , 4); > =A0.init ALIGN(__localization_end__ , 4) : > =A0{ > =A0 =A0__init_start__ =3D .; > =A0 =A0*(.init .init.*) > =A0} > =A0__init_end__ =3D __init_start__ + SIZEOF(.init); > > =A0. =3D ASSERT(__init_end__ >=3D __SDRAM_segment_start__ && __init_end__ > <=3D (__SDRAM_segment_start__ + 0x02000000) , "error: .init is too large > to fit in SDRAM memory segment"); > > =A0__text_load_start__ =3D ALIGN(__init_end__ , 4); > =A0.text ALIGN(__init_end__ , 4) : > =A0{ > =A0 =A0__text_start__ =3D .; > =A0 =A0*(.text .text.* .glue_7t .glue_7 .gnu.linkonce.t.*) > =A0} > =A0__text_end__ =3D __text_start__ + SIZEOF(.text); > > =A0. =3D ASSERT(__text_end__ >=3D __SDRAM_segment_start__ && __text_end__ > <=3D (__SDRAM_segment_start__ + 0x02000000) , "error: .text is too large > to fit in SDRAM memory segment"); > > =A0__dtors_load_start__ =3D ALIGN(__text_end__ , 4); > =A0.dtors ALIGN(__text_end__ , 4) : > =A0{ > =A0 =A0__dtors_start__ =3D .; > =A0 =A0KEEP (*(SORT(.dtors.*))) KEEP (*(.dtors)) > =A0} > =A0__dtors_end__ =3D __dtors_start__ + SIZEOF(.dtors); > > =A0. =3D ASSERT(__dtors_end__ >=3D __SDRAM_segment_start__ && __dtors_end= __ > <=3D (__SDRAM_segment_start__ + 0x02000000) , "error: .dtors is too > large to fit in SDRAM memory segment"); > > =A0__ctors_load_start__ =3D ALIGN(__dtors_end__ , 4); > =A0.ctors ALIGN(__dtors_end__ , 4) : > =A0{ > =A0 =A0__ctors_start__ =3D .; > =A0 =A0KEEP (*(SORT(.ctors.*))) KEEP (*(.ctors)) > =A0} > =A0__ctors_end__ =3D __ctors_start__ + SIZEOF(.ctors); > > =A0. =3D ASSERT(__ctors_end__ >=3D __SDRAM_segment_start__ && __ctors_end= __ > <=3D (__SDRAM_segment_start__ + 0x02000000) , "error: .ctors is too > large to fit in SDRAM memory segment"); > > =A0__fast_load_start__ =3D ALIGN(__ctors_end__ , 4); > =A0.fast ALIGN(__SRAM1_segment_start__ , 4) : AT(ALIGN(__ctors_end__ , 4)) > =A0{ > =A0 =A0__fast_start__ =3D .; > =A0 =A0*(.fast .fast.*) > =A0} > =A0__fast_end__ =3D __fast_start__ + SIZEOF(.fast); > > =A0__fast_load_end__ =3D __fast_load_start__ + SIZEOF(.fast); > > =A0. =3D ASSERT((__fast_load_start__ + SIZEOF(.fast)) >=3D > __SDRAM_segment_start__ && (__fast_load_start__ + SIZEOF(.fast)) <=3D > (__SDRAM_segment_start__ + 0x02000000) , "error: .fast is too large to > fit in SDRAM memory segment"); > > =A0.fast_run ALIGN(__SRAM1_segment_start__ , 4) (NOLOAD) : > =A0{ > =A0 =A0__fast_run_start__ =3D .; > =A0 =A0. =3D MAX(__fast_run_start__ + SIZEOF(.fast), .); > =A0} > =A0__fast_run_end__ =3D __fast_run_start__ + SIZEOF(.fast_run); > > =A0__SRAM1_segment_used_end__ =3D ALIGN(__SRAM1_segment_start__ , 4) + > SIZEOF(.fast_run); > > =A0. =3D ASSERT(__fast_run_end__ >=3D __SRAM1_segment_start__ && > __fast_run_end__ <=3D (__SRAM1_segment_start__ + 0x00001000) , "error: > .fast_run is too large to fit in SRAM1 memory segment"); > > =A0__data_load_start__ =3D ALIGN(__fast_load_start__ + SIZEOF(.fast) , 4); > =A0.data ALIGN(__fast_load_start__ + SIZEOF(.fast) , 4) : > =A0{ > =A0 =A0__data_start__ =3D .; > =A0 =A0*(.data .data.* .gnu.linkonce.d.*) > =A0} > =A0__data_end__ =3D __data_start__ + SIZEOF(.data); > > =A0. =3D ASSERT(__data_end__ >=3D __SDRAM_segment_start__ && __data_end__ > <=3D (__SDRAM_segment_start__ + 0x02000000) , "error: .data is too large > to fit in SDRAM memory segment"); > > =A0__rodata_load_start__ =3D ALIGN(__data_end__ , 4); > =A0.rodata ALIGN(__data_end__ , 4) : > =A0{ > =A0 =A0__rodata_start__ =3D .; > =A0 =A0*(.rodata .rodata.* .gnu.linkonce.r.*) > =A0} > =A0__rodata_end__ =3D __rodata_start__ + SIZEOF(.rodata); > > =A0. =3D ASSERT(__rodata_end__ >=3D __SDRAM_segment_start__ && > __rodata_end__ <=3D (__SDRAM_segment_start__ + 0x02000000) , "error: > .rodata is too large to fit in SDRAM memory segment"); > > =A0__bss_load_start__ =3D ALIGN(__rodata_end__ , 4); > =A0.bss ALIGN(__rodata_end__ , 4) (NOLOAD) : > =A0{ > =A0 =A0__bss_start__ =3D .; > =A0 =A0*(.bss .bss.* .gnu.linkonce.b.*) *(COMMON) > =A0} > =A0__bss_end__ =3D __bss_start__ + SIZEOF(.bss); > > =A0. =3D ASSERT(__bss_end__ >=3D __SDRAM_segment_start__ && __bss_end__ <= =3D > (__SDRAM_segment_start__ + 0x02000000) , "error: .bss is too large to > fit in SDRAM memory segment"); > > =A0__text_user_load_start__ =3D ALIGN(__bss_end__ , 4); > =A0.text_user ALIGN(__bss_end__ , 4) (NOLOAD) : > =A0{ > =A0 =A0__text_user_start__ =3D .; > =A0 =A0*(.text_user) > =A0} > =A0__text_user_end__ =3D __text_user_start__ + SIZEOF(.text_user); > > =A0. =3D ASSERT(__text_user_end__ >=3D __SDRAM_segment_start__ && > __text_user_end__ <=3D (__SDRAM_segment_start__ + 0x02000000) , "error: > .text_user is too large to fit in SDRAM memory segment"); > > =A0__non_init_load_start__ =3D ALIGN(__text_user_end__ , 4); > =A0.non_init ALIGN(__text_user_end__ , 4) (NOLOAD) : > =A0{ > =A0 =A0__non_init_start__ =3D .; > =A0 =A0*(.non_init .non_init.*) > =A0} > =A0__non_init_end__ =3D __non_init_start__ + SIZEOF(.non_init); > > =A0. =3D ASSERT(__non_init_end__ >=3D __SDRAM_segment_start__ && > __non_init_end__ <=3D (__SDRAM_segment_start__ + 0x02000000) , "error: > .non_init is too large to fit in SDRAM memory segment"); > > =A0__heap_load_start__ =3D ALIGN(__non_init_end__ , 4); > =A0.heap ALIGN(__non_init_end__ , 4) (NOLOAD) : > =A0{ > =A0 =A0__heap_start__ =3D .; > =A0 =A0*(.heap) > =A0 =A0. =3D ALIGN(MAX(__heap_start__ + __HEAPSIZE__ , .), 4); > =A0} > =A0__heap_end__ =3D __heap_start__ + SIZEOF(.heap); > > =A0. =3D ASSERT(__heap_end__ >=3D __SDRAM_segment_start__ && __heap_end__ > <=3D (__SDRAM_segment_start__ + 0x02000000) , "error: .heap is too large > to fit in SDRAM memory segment"); > > =A0__stack_load_start__ =3D ALIGN(__heap_end__ , 4); > =A0.stack ALIGN(__heap_end__ , 4) (NOLOAD) : > =A0{ > =A0 =A0__stack_start__ =3D .; > =A0 =A0*(.stack) > =A0 =A0. =3D ALIGN(MAX(__stack_start__ + __STACKSIZE__ , .), 4); > =A0} > =A0__stack_end__ =3D __stack_start__ + SIZEOF(.stack); > > =A0. =3D ASSERT(__stack_end__ >=3D __SDRAM_segment_start__ && __stack_end= __ > <=3D (__SDRAM_segment_start__ + 0x02000000) , "error: .stack is too > large to fit in SDRAM memory segment"); > > =A0__stack_irq_load_start__ =3D ALIGN(__stack_end__ , 4); > =A0.stack_irq ALIGN(__stack_end__ , 4) (NOLOAD) : > =A0{ > =A0 =A0__stack_irq_start__ =3D .; > =A0 =A0*(.stack_irq) > =A0 =A0. =3D ALIGN(MAX(__stack_irq_start__ + __STACKSIZE_IRQ__ , .), 4); > =A0} > =A0__stack_irq_end__ =3D __stack_irq_start__ + SIZEOF(.stack_irq); > > =A0. =3D ASSERT(__stack_irq_end__ >=3D __SDRAM_segment_start__ && > __stack_irq_end__ <=3D (__SDRAM_segment_start__ + 0x02000000) , "error: > .stack_irq is too large to fit in SDRAM memory segment"); > > =A0__stack_fiq_load_start__ =3D ALIGN(__stack_irq_end__ , 4); > =A0.stack_fiq ALIGN(__stack_irq_end__ , 4) (NOLOAD) : > =A0{ > =A0 =A0__stack_fiq_start__ =3D .; > =A0 =A0*(.stack_fiq) > =A0 =A0. =3D ALIGN(MAX(__stack_fiq_start__ + __STACKSIZE_FIQ__ , .), 4); > =A0} > =A0__stack_fiq_end__ =3D __stack_fiq_start__ + SIZEOF(.stack_fiq); > > =A0. =3D ASSERT(__stack_fiq_end__ >=3D __SDRAM_segment_start__ && > __stack_fiq_end__ <=3D (__SDRAM_segment_start__ + 0x02000000) , "error: > .stack_fiq is too large to fit in SDRAM memory segment"); > > =A0__stack_svc_load_start__ =3D ALIGN(__stack_fiq_end__ , 4); > =A0.stack_svc ALIGN(__stack_fiq_end__ , 4) (NOLOAD) : > =A0{ > =A0 =A0__stack_svc_start__ =3D .; > =A0 =A0*(.stack_svc) > =A0 =A0. =3D ALIGN(MAX(__stack_svc_start__ + __STACKSIZE_SVC__ , .), 4); > =A0} > =A0__stack_svc_end__ =3D __stack_svc_start__ + SIZEOF(.stack_svc); > > =A0. =3D ASSERT(__stack_svc_end__ >=3D __SDRAM_segment_start__ && > __stack_svc_end__ <=3D (__SDRAM_segment_start__ + 0x02000000) , "error: > .stack_svc is too large to fit in SDRAM memory segment"); > > =A0__stack_abt_load_start__ =3D ALIGN(__stack_svc_end__ , 4); > =A0.stack_abt ALIGN(__stack_svc_end__ , 4) (NOLOAD) : > =A0{ > =A0 =A0__stack_abt_start__ =3D .; > =A0 =A0*(.stack_abt) > =A0 =A0. =3D ALIGN(MAX(__stack_abt_start__ + __STACKSIZE_ABT__ , .), 4); > =A0} > =A0__stack_abt_end__ =3D __stack_abt_start__ + SIZEOF(.stack_abt); > > =A0. =3D ASSERT(__stack_abt_end__ >=3D __SDRAM_segment_start__ && > __stack_abt_end__ <=3D (__SDRAM_segment_start__ + 0x02000000) , "error: > .stack_abt is too large to fit in SDRAM memory segment"); > > =A0__stack_und_load_start__ =3D ALIGN(__stack_abt_end__ , 4); > =A0.stack_und ALIGN(__stack_abt_end__ , 4) (NOLOAD) : > =A0{ > =A0 =A0__stack_und_start__ =3D .; > =A0 =A0*(.stack_und) > =A0 =A0. =3D ALIGN(MAX(__stack_und_start__ + __STACKSIZE_UND__ , .), 4); > =A0} > =A0__stack_und_end__ =3D __stack_und_start__ + SIZEOF(.stack_und); > > =A0. =3D ASSERT(__stack_und_end__ >=3D __SDRAM_segment_start__ && > __stack_und_end__ <=3D (__SDRAM_segment_start__ + 0x02000000) , "error: > .stack_und is too large to fit in SDRAM memory segment"); > > =A0__exceptions_log_load_start__ =3D 0x21eff000; > =A0.exceptions_log 0x21eff000 (NOLOAD) : > =A0{ > =A0 =A0__exceptions_log_start__ =3D .; > =A0 =A0*(.exceptions_log) > =A0 =A0. =3D MAX(__exceptions_log_start__ + 0x1000 , .); > =A0} > =A0__exceptions_log_end__ =3D __exceptions_log_start__ + SIZEOF(.exceptio= ns_log); > > =A0. =3D ASSERT(__exceptions_log_end__ >=3D __SDRAM_segment_start__ && > __exceptions_log_end__ <=3D (__SDRAM_segment_start__ + 0x02000000) , > "error: .exceptions_log is too large to fit in SDRAM memory segment"); > > =A0. =3D ASSERT(__stack_und_end__ <=3D __exceptions_log_start__ , "error: > section .stack_und overlaps absolute placed section .exceptions_log"); > > =A0__nocache_load_start__ =3D 0x21f00000; > =A0.nocache 0x21f00000 (NOLOAD) : > =A0{ > =A0 =A0__nocache_start__ =3D .; > =A0 =A0*(.nocache) > =A0} > =A0__nocache_end__ =3D __nocache_start__ + SIZEOF(.nocache); > > =A0__SDRAM_segment_used_end__ =3D 0x21f00000 + SIZEOF(.nocache); > > =A0. =3D ASSERT(__nocache_end__ >=3D __SDRAM_segment_start__ && > __nocache_end__ <=3D (__SDRAM_segment_start__ + 0x02000000) , "error: > .nocache is too large to fit in SDRAM memory segment"); > > =A0. =3D ASSERT(__exceptions_log_end__ <=3D __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 >