This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

[参考译文] TMS320F28388D:链接器文件不工作、内存不足。

Guru**** 2589300 points


请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

https://e2e.ti.com/support/microcontrollers/c2000-microcontrollers-group/c2000/f/c2000-microcontrollers-forum/1128185/tms320f28388d-linker-file-not-working-insufficient-memory

器件型号:TMS320F28388D

总结  

当前正在将 Simulink 模型转换为另一个 CPU。 修改 了 cmd 文件。 我已修改了我的 cmd 文件以尝试解决 内存问题(通过修改第25行)。

我认为内存分配不够大。  我已阅读链接器脚本入门、但不确定如何解决。 我还链接了 cmd 文件。

#include "MW_F2838x_MemoryMap.h"
#ifdef CLA_BLOCK_INCLUDED
// Define a size for the CLA scratchpad area that will be used
// by the CLA compiler for local symbols and temps
// Also force references to the special symbols that mark the
// scratchpad are. 
CLA_SCRATCHPAD_SIZE = 0x100;
--undef_sym=__cla_scratchpad_end
--undef_sym=__cla_scratchpad_start
#endif //CLA_BLOCK_INCLUDED
MEMORY
{
PAGE 0 :
   /* BEGIN is used for the "boot to SARAM" bootloader mode   */
   BEGIN                    : origin = 0x000000,                length = 0x000002
   BEGIN_FLASH              : origin = 0x080000,                length = 0x000002
   #ifdef CLA_BLOCK_INCLUDED
        #if (CPU_RAMLS_PROG_LENGTH > 0)
            RAMLS_PROG      : origin = CPU_RAMLS_PROG_START,    length = CPU_RAMLS_PROG_LENGTH
        #endif //CPU_RAMLS_PROG_LENGTH
        RAMLS_CLA_PROG      : origin = CLA_RAMLS_PROG_START, 	length = CLA_RAMLS_PROG_LENGTH
        RAMLS_CLA_DATA      : origin = CLA_RAMLS_DATA_START, 	length = CLA_RAMLS_DATA_LENGTH
   #else
        #if BOOT_FROM_FLASH
            RAMLS_PROG      : origin = 0x008000, 				length = 0x003800 //Modified
        #else
            RAMLS_PROG      : origin = 0x008000, 				length = 0x004000
        #endif //BOOT_FROM_FLASH
   #endif //CLA_BLOCK_INCLUDED
   
   #ifdef CPU1       
        #if (CPU1_RAMGS_PROG_LENGTH > 0)
            RAMGS_PROG      : origin = CPU1_RAMGS_PROG_START, 	length = CPU1_RAMGS_PROG_LENGTH
        #endif //(CPU1_RAMGS_PROG_LENGTH > 0)
   #else
        #if (CPU2_RAMGS_PROG_LENGTH > 0)
            RAMGS_PROG      : origin = CPU2_RAMGS_PROG_START, 	length = CPU2_RAMGS_PROG_LENGTH
       #endif //(CPU2_RAMGS_PROG_LENGTH > 0)
   #endif //CPU1

   /* Flash sectors */
   FLASHA_N                 : origin = 0x080002, 				length = 0x03FFFE	/* on-chip Flash */ 
   RESET                    : origin = 0x3FFFC0,                length = 0x000002
   
PAGE 1 :
   BOOT_RSVD           		: origin = 0x000002, 				length = 0x0001AE     /* Part of M0, BOOT rom will use this for stack */
   RAMM0M1                  : origin = 0x0001B0,                length = 0x000650
   RAMD0D1                  : origin = 0x00C000,                length = 0x001000
   
   #ifndef CLA_BLOCK_INCLUDED
        #if BOOT_FROM_FLASH
            RAMLS_DATA      : origin = 0x00A800, 				length = 0x001800
        #endif //BOOT_FROM_FLASH
   #endif //CLA_BLOCK_INCLUDED
   
   #ifdef CPU1       
        RAMGS_DATA       	: origin = CPU1_RAMGS_DATA_START, 	length = CPU1_RAMGS_DATA_LENGTH
   #else	
		RAMGS_DATA       	: origin = CPU2_RAMGS_DATA_START, 	length = CPU2_RAMGS_DATA_LENGTH
   #endif //CPU1
   
   RAMGS_IPCBuffCPU1        : origin = RAMGS_IPC_CPU1_START,          length = RAMGS_IPC_CPU1_LENGTH
   RAMGS_IPCBuffCPU2        : origin = RAMGS_IPC_CPU2_START,          length = RAMGS_IPC_CPU2_LENGTH
   
   CLA1_MSGRAMLOW           : origin = 0x001480,                length = 0x000080
   CLA1_MSGRAMHIGH          : origin = 0x001500,                length = 0x000080
   
   CPU1TOCPU2RAM            : origin = 0x03A000,                length = 0x000800
   CPU2TOCPU1RAM            : origin = 0x03B000,                length = 0x000800
   
   CPUTOCMRAM               : origin = 0x039000,                length = 0x000800
   CMTOCPURAM               : origin = 0x038000,                length = 0x000800
   
   CANA_MSG_RAM             : origin = 0x049000,                length = 0x000800
   CANB_MSG_RAM             : origin = 0x04B000,                length = 0x000800
   
   #ifdef EMIF1_CS0_INCLUDED
      EMIF1_CS0_MEMORY    : origin = 0x80000000,                length = 0x10000000
   #endif //EMIF1_CS0_INCLUDED
   #ifdef EMIF1_CS2_INCLUDED
      EMIF1_CS2_MEMORY    : origin = 0x00100000,                length = 0x00200000
   #endif //EMIF1_CS2_INCLUDED
   #ifdef EMIF1_CS3_INCLUDED
      EMIF1_CS3_MEMORY    : origin = 0x00300000, 				length = 0x00080000
   #endif //EMIF1_CS3_INCLUDED				
   #ifdef EMIF1_CS4_INCLUDED				
      EMIF1_CS4_MEMORY    : origin = 0x00380000, 				length = 0x00060000
   #endif //EMIF1_CS4_INCLUDED				
   #ifdef EMIF2_CS0_INCLUDED				
      EMIF2_CS0_MEMORY    : origin = 0x90000000, 				length = 0x10000000
   #endif //EMIF2_CS0_INCLUDED				
   #ifdef EMIF2_CS2_INCLUDED				
      EMIF2_CS2_MEMORY    : origin = 0x00002000, 				length = 0x00001000
   #endif //EMIF2_CS2_INCLUDED
}

SECTIONS
{
#if BOOT_FROM_FLASH
   /* Allocate program areas: */
   codestart                : > BEGIN_FLASH,              PAGE = 0,        ALIGN(8)
   .text                    : > FLASHA_N,                 PAGE = 0,        ALIGN(8)
   .cinit                   : > FLASHA_N,                 PAGE = 0,        ALIGN(8)
   .switch                  : > FLASHA_N,                 PAGE = 0,        ALIGN(8)
    #if defined(__TI_EABI__)
        .init_array         : > FLASHA_N,                 PAGE = 0,        ALIGN(8)
       /* Initalized sections go in Flash */
       .const               : > FLASHA_N,                 PAGE = 0,        ALIGN(8)
       .data                : > RAMGS_DATA,               PAGE = 1
       .TI.ramfunc          : {} LOAD = FLASHA_N,
                             #if CPU_RAMLS_PROG_LENGTH>0
                             RUN =  RAMLS_PROG,
                             #else
                             RUN = RAMGS_PROG,
                             #endif
                             LOAD_START(RamfuncsLoadStart),
                             LOAD_SIZE(RamfuncsLoadSize),
                             LOAD_END(RamfuncsLoadEnd),
                             RUN_START(RamfuncsRunStart),
                             RUN_SIZE(RamfuncsRunSize),
                             RUN_END(RamfuncsRunEnd),
                             PAGE = 0, ALIGN(8)

       ramfuncs          	: LOAD = FLASHA_N,
                             #if CPU_RAMLS_PROG_LENGTH>0
                             RUN =  RAMLS_PROG,
                             #else // Applicable when CLA BLOCK is included and CPULSRAM is zero
                             RUN = RAMGS_PROG,
                             #endif
                             LOAD_START(MW_RamfuncsLoadStart),
                             LOAD_SIZE(MW_RamfuncsLoadSize),
                             LOAD_END(MW_RamfuncsLoadEnd),
                             RUN_START(MW_RamfuncsRunStart),
                             RUN_SIZE(MW_RamfuncsRunSize),
                             RUN_END(MW_RamfuncsRunEnd),
                             PAGE = 0, ALIGN(8)
    #else
        .pinit              : > FLASHA_N,                 PAGE = 0,        ALIGN(8)
       /* Initalized sections go in Flash */
       .econst              : > FLASHA_N,                 PAGE = 0,        ALIGN(8)
       .TI.ramfunc          : {} LOAD = FLASHA_N,
                             #if CPU_RAMLS_PROG_LENGTH>0
                             RUN =  RAMLS_PROG,
                             #else // Applicable when CLA BLOCK is included and CPULSRAM is zero
                             RUN = RAMGS_PROG,
                             #endif
                             LOAD_START(_RamfuncsLoadStart),
                             LOAD_SIZE(_RamfuncsLoadSize),
                             LOAD_END(_RamfuncsLoadEnd),
                             RUN_START(_RamfuncsRunStart),
                             RUN_SIZE(_RamfuncsRunSize),
                             RUN_END(_RamfuncsRunEnd),
                             PAGE = 0, ALIGN(8)

        ramfuncs          	: LOAD = FLASHA_N,
                             #if CPU_RAMLS_PROG_LENGTH>0
                             RUN =  RAMLS_PROG,
                             #else // Applicable when CLA BLOCK is included and CPULSRAM is zero
                             RUN = RAMGS_PROG,
                             #endif
                             LOAD_START(_MW_RamfuncsLoadStart),
                             LOAD_SIZE(_MW_RamfuncsLoadSize),
                             LOAD_END(_MW_RamfuncsLoadEnd),
                             RUN_START(_MW_RamfuncsRunStart),
                             RUN_SIZE(_MW_RamfuncsRunSize),
                             RUN_END(_MW_RamfuncsRunEnd),
                             PAGE = 0, ALIGN(8)
    #endif // defined(__TI_EABI__)
    #ifdef CLA_BLOCK_INCLUDED
            #if defined(__TI_EABI__)
                /* CLA specific sections */
                Cla1Prog    : LOAD = FLASHA_N,
                              RUN = RAMLS_CLA_PROG,
                              LOAD_START(Cla1funcsLoadStart),
                              LOAD_END(Cla1funcsLoadEnd),
                              RUN_START(Cla1funcsRunStart),
                              LOAD_SIZE(Cla1funcsLoadSize),
                              PAGE = 0, ALIGN(8)
                .const_cla  : LOAD = FLASHA_N,
                              RUN = RAMLS_CLA_DATA,
                              RUN_START(Cla1ConstRunStart),
                              LOAD_START(Cla1ConstLoadStart),
                              LOAD_SIZE(Cla1ConstLoadSize),
                              PAGE = 0
                .bss        : > RAMGS_DATA,               PAGE = 1
                .bss:output : > RAMGS_DATA,               PAGE = 1
                .bss:cio    : > RAMGS_DATA,               PAGE = 1
            #else
                /* CLA specific sections */
                Cla1Prog    : LOAD = FLASHA_N,
                              RUN = RAMLS_CLA_PROG,
                              LOAD_START(_Cla1funcsLoadStart),
                              LOAD_END(_Cla1funcsLoadEnd),
                              RUN_START(_Cla1funcsRunStart),
                              LOAD_SIZE(_Cla1funcsLoadSize),
                              PAGE = 0, ALIGN(8)
                .const_cla	: LOAD = FLASHA_N,
                              RUN = RAMLS_CLA_DATA,
                              RUN_START(_Cla1ConstRunStart),
                              LOAD_START(_Cla1ConstLoadStart),
                              LOAD_SIZE(_Cla1ConstLoadSize),
                              PAGE = 0
                .ebss       : > RAMGS_DATA,               PAGE = 1
            #endif // defined(__TI_EABI__)
       #else
            #if defined(__TI_EABI__)
                .bss        : >> RAMGS_DATA | RAMLS_DATA, PAGE = 1
            #else
                .ebss       : >> RAMGS_DATA | RAMLS_DATA, PAGE = 1
            #endif // defined(__TI_EABI__)
       #endif //CLA_BLOCK_INCLUDED

   /* Allocate IQmath areas: */
   IQmath			        : > FLASHA_N,                 PAGE = 0,      ALIGN(8)  /* Math Code */
   IQmathTables		        : > FLASHA_N,                 PAGE = 0,      ALIGN(8)   
      
#else
   codestart        	    : > BEGIN,                    PAGE = 0
   .text                    : >> RAMLS_PROG | RAMGS_PROG, PAGE = 0
    #if (CPU1_RAMGS_PROG_LENGTH > 0)
      .cinit           	    : > RAMGS_PROG,               PAGE = 0
    #else
      .cinit           	    : > RAMLS_PROG,               PAGE = 0
    #endif
   .switch          	    : >> RAMLS_PROG  | RAMGS_PROG, PAGE = 0
   .TI.ramfunc              : >> RAMLS_PROG  | RAMGS_PROG, PAGE = 0
   ramfuncs         	    : >> RAMLS_PROG  | RAMGS_PROG, PAGE = 0
    #if defined(__TI_EABI__)
        .bss                : >  RAMGS_DATA,               PAGE = 1
        .bss:output         : >  RAMGS_DATA,               PAGE = 1
        .bss:cio            : >  RAMGS_DATA,               PAGE = 1
        .init_array         : >> RAMLS_PROG | RAMGS_PROG,  PAGE = 0
        .const              : >> RAMLS_PROG | RAMGS_PROG,  PAGE = 0
        .data               : >  RAMGS_DATA,               PAGE = 1
    #else
        .ebss               : >  RAMGS_DATA,               PAGE = 1
        .pinit              : >> RAMLS_PROG | RAMGS_PROG,  PAGE = 0
        .const              : >> RAMLS_PROG | RAMGS_PROG,  PAGE = 0
    #endif // defined(__TI_EABI__)
   /* Allocate IQ math areas: */
   IQmath				    : >> RAMLS_PROG | RAMGS_PROG,  PAGE = 0	/* Math Code */
   IQmathTables			    : >> RAMLS_PROG | RAMGS_PROG,  PAGE = 0
   #ifdef CLA_BLOCK_INCLUDED
       /* CLA specific sections */
       Cla1Prog             : > RAMLS_CLA_PROG,           PAGE = 0
       .const_cla           : > RAMLS_CLA_DATA,           PAGE = 0
   #endif //CLA_BLOCK_INCLUDED
#endif //BOOT_FROM_FLASH 
    #if defined(__TI_EABI__)
        .sysmem             : > RAMD0D1,                  PAGE = 1
    #else
       .esysmem             : > RAMD0D1,                  PAGE = 1
       .cio                 : > RAMGS_DATA,               PAGE = 1
    #endif // defined(__TI_EABI__)
   .stack                   : > RAMM0M1,                  PAGE = 1
   .reset                   : > RESET,                    PAGE = 0,      TYPE = DSECT /* not used, */
   MSGRAM_CPU1_TO_CPU2      : > CPU1TOCPU2RAM,            PAGE = 1
   MSGRAM_CPU2_TO_CPU1      : > CPU2TOCPU1RAM,            PAGE = 1
   MSGRAM_CPU_TO_CM         : > CPUTOCMRAM,               PAGE = 1
   MSGRAM_CM_TO_CPU         : > CMTOCPURAM,               PAGE = 1   
   #if defined(EMIF1_CS0_INCLUDED) && defined(EMIF2_CS0_INCLUDED)
      .farbss               : > EMIF1_CS0_MEMORY | EMIF2_CS0_MEMORY,      PAGE = 1
      .farconst             : > EMIF1_CS0_MEMORY | EMIF2_CS0_MEMORY,      PAGE = 1
   #elif !defined(EMIF1_CS0_INCLUDED) && defined(EMIF2_CS0_INCLUDED)
      .farbss               : > EMIF2_CS0_MEMORY,          PAGE = 1
      .farconst             : > EMIF2_CS0_MEMORY,          PAGE = 1
   #elif defined(EMIF1_CS0_INCLUDED) && !defined(EMIF2_CS0_INCLUDED)
      .farbss              : > EMIF1_CS0_MEMORY,          PAGE = 1
      .farconst            : > EMIF1_CS0_MEMORY,          PAGE = 1
   #else
      //No EMIF memory sections
   #endif //defined(EMIF1_CS0_INCLUDED) && defined(EMIF2_CS0_INCLUDED)
   #ifdef EMIF1_CS0_INCLUDED
      Em1Cs0               : > EMIF1_CS0_MEMORY,          PAGE = 1
   #endif //EMIF1_CS0_INCLUDED
   #ifdef EMIF2_CS0_INCLUDED
       Em2Cs0              : > EMIF2_CS0_MEMORY,          PAGE = 1
   #endif //EMIF2_CS0_INCLUDED
   #ifdef EMIF1_CS2_INCLUDED
       Em1Cs2              : > EMIF1_CS2_MEMORY,          PAGE = 1
   #endif //EMIF1_CS2_INCLUDED
   #ifdef EMIF1_CS3_INCLUDED
       Em1Cs3              : > EMIF1_CS3_MEMORY,          PAGE = 1
   #endif //EMIF1_CS3_INCLUDED
   #ifdef EMIF1_CS4_INCLUDED
       Em1Cs4              : > EMIF1_CS4_MEMORY,          PAGE = 1
   #endif //EMIF1_CS4_INCLUDED
   #ifdef MW_EMIF2_CS2_INCLUDED
       Em2Cs2              : > EMIF2_CS2_MEMORY,          PAGE = 1
   #endif //MW_EMIF2_CS2_INCLUDED   
   #ifdef CLA_BLOCK_INCLUDED
       /* CLA C compiler sections */
       //
       // Must be allocated to memory the CLA has write access to
       //
       Cla1DataRam0		    : > RAMLS_CLA_DATA,           PAGE = 0

       Cla1ToCpuMsgRAM      : > CLA1_MSGRAMLOW, type=NOINIT               PAGE = 1
       CpuToCla1MsgRAM      : > CLA1_MSGRAMHIGH, type=NOINIT              PAGE = 1
       CLAscratch           :
                             { 
							     *.obj(CLAscratch)
							     . += CLA_SCRATCHPAD_SIZE;
							     *.obj(CLAscratch_end) 
						     } >  RAMLS_CLA_DATA,         PAGE = 0

       .scratchpad          : > RAMLS_CLA_DATA,           PAGE = 0
       .bss_cla		        : > RAMLS_CLA_DATA,           PAGE = 0
   #endif //CLA_BLOCK_INCLUDED

  #if defined(CPU1)  
       /* The following section definitions are required when using the IPC API Drivers */
            GROUP : > CPU1TOCPU2RAM,                      PAGE = 1
            {
                PUTBUFFER 
                PUTWRITEIDX 
                GETREADIDX 
                WRITEFLAG1CPU1
                WRITEFLAG2CPU1
                READFLAG1CPU1
                READFLAG2CPU1
            }
            GROUP : > CPU2TOCPU1RAM,                      PAGE = 1
            {
                GETBUFFER :     TYPE = DSECT
                GETWRITEIDX :   TYPE = DSECT
                PUTREADIDX :    TYPE = DSECT
                WRITEFLAG1CPU2 : TYPE = DSECT
                WRITEFLAG2CPU2 : TYPE = DSECT
                READFLAG1CPU2  : TYPE = DSECT
                READFLAG2CPU2  : TYPE = DSECT
            }
   #else
       /* The following section definitions are required when using the IPC API Drivers */ 
            GROUP : > CPU2TOCPU1RAM,                      PAGE = 1
            {
                PUTBUFFER 
                PUTWRITEIDX 
                GETREADIDX 
                WRITEFLAG1CPU2
                WRITEFLAG2CPU2
                READFLAG1CPU2			
                READFLAG2CPU2			
            }
            GROUP : > CPU1TOCPU2RAM,                      PAGE = 1
            {
                GETBUFFER :     TYPE = DSECT
                GETWRITEIDX :   TYPE = DSECT
                PUTREADIDX :    TYPE = DSECT
                WRITEFLAG1CPU1 : TYPE = DSECT
                WRITEFLAG2CPU1 : TYPE = DSECT
                READFLAG1CPU1  : TYPE = DSECT
                READFLAG2CPU1  : TYPE = DSECT
            }
   #endif //CPU1

    GROUP : > CPUTOCMRAM,                                 PAGE = 1
    {
        PUTBUFFERCPUX
        PUTWRITEIDXCPUX
        GETREADIDXCPUX
        WRITEFLAG1CPUX
        WRITEFLAG2CPUX
        READFLAG1CPUX
        READFLAG2CPUX
        VECTORDATA
    }
    GROUP : > CMTOCPURAM,                                 PAGE = 1
    {
        GETBUFFERCM :     TYPE = DSECT
        GETWRITEIDXCM :   TYPE = DSECT
        PUTREADIDXCM :    TYPE = DSECT
        WRITEFLAG1CM : TYPE = DSECT
        WRITEFLAG2CM : TYPE = DSECT
        READFLAG1CM  : TYPE = DSECT
        READFLAG2CM  : TYPE = DSECT
        VECTORDATA   : TYPE = DSECT
    } 

	GROUP : > RAMGS_IPCBuffCPU1,                          PAGE = 1
	{
		CPU1TOCPU2GSRAM
	}
	GROUP : > RAMGS_IPCBuffCPU2,                          PAGE = 1
	{
		CPU2TOCPU1GSRAM
	}
}

/*
//===========================================================================
// End of file.
//===========================================================================
*/

警告

在 CCS 中重建时


"C:/src/c2838x.cmd"、第124行:错误:
程序不能放入可用的存储器中、或者该段包含调用
需要无法为此段生成的 trampoline 的站点。
段"ramfuncs"大小的运行定位/分块失败
0x35c6page 0。 可用存储器范围:
RAMLS_PROG 大小:0x2800未使用:0x2800最大孔:0x2800


"C:/c2838x.cmd"、第207行:错误:
程序不能放入可用的存储器中、或者该段包含调用
需要无法为此段生成的 trampoline 的站点。
段".bss"大小的运行定位/分块失败
bbb8cbpage 1. 可用存储器范围:
RAMGS_DATA 大小:0x5000未使用:0x2d02最大空洞:0x2ce
RAMLS_DATA 大小:0x1800未使用:0x1800最大孔:0x1800
错误:链接过程中遇到错误;
未构建"program.out"

是否有任何操作方法或调试方法?

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    您有许多编译器开关、因此很难看到哪些是活动的、哪些不是活动的。 也许只发布那些处于活动状态的部分? 例如、CPU_RAMLS_PROG_LENGTH 的值是多少?

    我猜您正在尝试从 RAM 运行所有内容。 如果是这样、这不可能适用于大型程序、您需要更具选择性。 现在、从闪存运行所有内容、直到您掌握每个输入段的大小。

    搜索以下行并将其删除、以防止它们在 RAM 中运行。

    #pragma CODE_SECTION (functionName、"ramfuncs");

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    你(们)好  
    这是 Simulink Embedded Coder Mathworks 提供的通用 cmd 文件。 我想在闪存中运行整个程序。 出于某种原因、默认预设是在 RAM 中运行程序。  

    此函数不在我的 cmd 文件 #pragma CODE_SECTION (functionName、"ramfuncs")中;
    我是否可以从 C2000 SDK 中使用 cmd 文件?

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。
    [引用 userid="495710" URL"~/support/microcontrollers/C2000-microcontrollers-group/CC2000/f/C2000-microcontrollers-forum/1128185/tms320f28388d-linker-file-working-insufficient memory/4185cmd#4185995"]此函数不在我的文件中, #ramma" pragma (functions[")部分

    pragma 只会出现在源代码中、而不是链接器文件中。 顺便说一下、末尾的分号是一个拼写错误、抱歉! 这是一种有选择性地将函数名称直接指向特定链接器段的方法、在本例中为"ramfuncs"。 我猜这会出现在您的源代码中、因为您的问题是 ramfuncs 太大、无法容纳在分配的物理内存中。

    当您的源代码中不存在 CODE_SECTION (即您已删除)时、默认情况下、程序代码将链接到.text。 如果随后将 boot_from _flash 定义为1、.text 将被分配给闪存存储器、并且您的程序可能会成功链接。

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。
    [引用 userid="495710" URL"~/support/microriors/c2000-microoptics-group/C2000/f/c2000-microrier-forum/1128185/tms320f28388d-linker-file-working-insufficient memory"]我已经阅读了链接器脚本

    我认为您还需要编译器手册:

    www.ti.com/.../spru514y.pdf