TMS320F280033: 对于具备二次Bootloader的项目，如何将库文件分配到指定扇区

MEMORY
{
   BEGIN            : origin = 0x00080000, length = 0x00000002
   BOOT_RSVD        : origin = 0x00000002, length = 0x00000126

   RAMM0            : origin = 0x00000128, length = 0x000002D8
   RAMM1            : origin = 0x00000400, length = 0x000003F8
   // RAMM1_RSVD       : origin = 0x000007F8, length = 0x00000008 /* Reserve and do not use for code as per the errata advisory "Memory: Prefetching Beyond Valid Memory" */

   // RAMLS0           : origin = 0x00008000, length = 0x00000800
   // RAMLS1           : origin = 0x00008800, length = 0x00000800
   // RAMLS2           : origin = 0x00009000, length = 0x00000800
   // RAMLS3           : origin = 0x00009800, length = 0x00000800
   // RAMLS4           : origin = 0x0000A000, length = 0x00000800
   // RAMLS5           : origin = 0x0000A800, length = 0x00000800

   // RAMLS6           : origin = 0x0000B000, length = 0x00000800
   // RAMLS7           : origin = 0x0000B800, length = 0x00000800

   // RAMGS0           : origin = 0x0000C000, length = 0x00001000
   // RAMGS1           : origin = 0x0000D000, length = 0x00001000
   // RAMGS2           : origin = 0x0000E000, length = 0x00001000
   // RAMGS3           : origin = 0x0000F000, length = 0x00000FF8
   // // RAMGS3_RSVD      : origin = 0x0000FFF8, length = 0x00000008 /* Reserve and do not use for code as per the errata advisory "Memory: Prefetching Beyond Valid Memory" */

   RAML_Data        : origin = 0x00008000, length = 0x00002000
   RAML_Prog        : origin = 0x0000A000, length = 0x00002000
   RAMG_All         : origin = 0x0000C000, length = 0x00003FF8

   BOOTROM          : origin = 0x003F8000, length = 0x00007FC0
   SECURE_ROM       : origin = 0x003F2000, length = 0x00006000

   RESET            : origin = 0x003FFFC0, length = 0x00000002
   /* Flash sectors */
   /* BANK 0 */
   BEGIN_BOOT        : origin = 0x088000, length = 0x000008 ,fill = 0xFFFF/* codestart         */
   BOOT_STARTFLAG    : origin = 0x088008, length = 0x000010	,fill = 0xFFFF/* bootloader flag   */
   BOOT_VERSION      : origin = 0x088018, length = 0x000008	,fill = 0xFFFF/* bootloader version*/
   BOOT_FLASH        : origin = 0x088020, length = 0x001FD0	,fill = 0xFFFF/* bootloader code   */
   BOOT_DATETIME     : origin = 0x089FF0, length = 0x000008	,fill = 0xFFFF/* bootloader compile datetime   */
   BOOT_FINISHFLAG   : origin = 0x089FF8, length = 0x000008	,fill = 0xFFFF/* bootloader finish flag   */

   APP1_BEGIN        : origin = 0x08A000, length = 0x000008 //,fill = 0xFFFF/* codestart         */
   APP1_STARTFLAG    : origin = 0x08A008, length = 0x000010	//,fill = 0xFFFF/* app1 flag   */
   APP1_VERSION      : origin = 0x08A018, length = 0x000008	//,fill = 0xFFFF/* app1 version*/
   APP1_FLASH        : origin = 0x08A020, length = 0x005FD0	//,fill = 0xFFFF/* app1 code */
   APP1_DATETIME     : origin = 0x08FFF0, length = 0x000008	//,fill = 0xFFFF/* app1 compile datetime */
   APP1_FINISHFLAG   : origin = 0x08FFF8, length = 0x000008	//,fill = 0xFFFF/* app1 finish flag   */
   /* BANK 1 */
   APP_ALGORITHM     : origin = 0x090000, length = 0x002000 //,fill = 0xFFFF/* share algorithm code      */
   APP2_BEGIN        : origin = 0x092000, length = 0x000008 //,fill = 0xFFFF/* codestart         */
   APP2_STARTFLAG    : origin = 0x092008, length = 0x000010	//,fill = 0xFFFF/* app2 flag   */
   APP2_VERSION      : origin = 0x092018, length = 0x000008	//,fill = 0xFFFF/* app2 version*/
   APP2_FLASH        : origin = 0x092020, length = 0x005FD0	//,fill = 0xFFFF/* app2 code */
   APP2_DATETIME     : origin = 0x097FF0, length = 0x000008	//,fill = 0xFFFF/* app2 compile datetime */
   APP2_FINISHFLAG   : origin = 0x097FF8, length = 0x000008	//,fill = 0xFFFF/* app2 finish flag   */

// FLASH_BANK0_SEC15_RSVD     : origin = 0x0AFFF0, length = 0x000010  /* Reserve and do not use for code as per the errata advisory "Memory: Prefetching Beyond Valid Memory" */

}



SECTIONS
{
   codestart        : > BEGIN_BOOT, ALIGN(8)
   .text            : > BOOT_FLASH, ALIGN(8)
   .cinit           : > BOOT_FLASH, ALIGN(8)
   .switch          : > BOOT_FLASH, ALIGN(8)
   .reset           : > RESET,                  TYPE = DSECT /* not used, */

   .stack           : > RAMM0 | RAMM1

   .init_array      : > BOOT_FLASH,  ALIGN(8)
   .bss             : > RAMG_All
   .bss:output      : > RAMG_All
   .bss:cio         : > RAMG_All
   .data            : > RAMG_All
   .sysmem          : > RAMG_All
   .const           : > BOOT_FLASH,  ALIGN(8)

   //  /*  Allocate IQ math areas: */
   // IQmath           : > FLASH_BANK0_SEC1, ALIGN(8)
   // IQmathTables     : > FLASH_BANK0_SEC2, ALIGN(8)

   // flashApi       :{ -l FAPI_F28003x.lib } > APP_ALGORITHM
     GROUP
   {
       .TI.ramfunc
       {
//           -l sfra_f64_tmu_eabi.lib
       }
       ramfuncs
       isrcodefuncs
      dclfuncs
   } LOAD = BOOT_FLASH,
         RUN = RAML_Prog,
         LOAD_START(RamfuncsLoadStart),
         LOAD_SIZE(RamfuncsLoadSize),
         LOAD_END(RamfuncsLoadEnd),
         RUN_START(RamfuncsRunStart),
         RUN_SIZE(RamfuncsRunSize),
         RUN_END(RamfuncsRunEnd),
         ALIGN(8)

     GROUP
   {
       algorithmfuncs
       {
//           -l sfra_f64_tmu_eabi.lib
         -l FAPI_F28003x_EABI_v1.58.10.lib
//         -l rts2800_fpu32_eabi.lib
       }
   } LOAD = APP_ALGORITHM,
         RUN = RAML_Prog,
         LOAD_START(LibfuncsLoadStart),
         LOAD_SIZE(LibfuncsLoadSize),
         LOAD_END(LibfuncsLoadEnd),
         RUN_START(LibfuncsRunStart),
         RUN_SIZE(LibfuncsRunSize),
         RUN_END(LibfuncsRunEnd),
         ALIGN(8)

   // SFRA_F32_Data    : > RAMG_All, ALIGN = 64
   // SFRA_Data		  : > RAMG_All, ALIGN = 64

   // FPUmathTables    : > APP1_FLASH

   boot_startflag    : > BOOT_STARTFLAG,     ALIGN(8)
   boot_version      : > BOOT_VERSION,       ALIGN(8)
   boot_datetime     : > BOOT_DATETIME,      ALIGN(8)
   boot_finishflag   : > BOOT_FINISHFLAG,    ALIGN(8)

   app1_startflag    : > APP1_STARTFLAG,     ALIGN(8)
   app1_version      : > APP1_VERSION,       ALIGN(8)
   app1_datetime     : > APP1_DATETIME,      ALIGN(8)
   app1_finishflag   : > APP1_FINISHFLAG,    ALIGN(8)

   app2_startflag    : > APP2_STARTFLAG,     ALIGN(8)
   app2_version      : > APP2_VERSION,       ALIGN(8)
   app2_datetime     : > APP2_DATETIME,      ALIGN(8)
   app2_finishflag   : > APP2_FINISHFLAG,    ALIGN(8)

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

warning #10278-D: LOAD placement specified for section ".text:decompress:none:rts2800_fpu32_eabi.lib<copy_decompress_none.c.obj>". This section contains decompression routines required for linker generated copy tables and C/C++ auto-initialization. Must ensure that this section is copied to run address before the C/C++ boot code is executed or is placed with single allocation specifier (ex. "> MEMORY").
warning #10278-D: LOAD placement specified for section ".text:rts2800_fpu32_eabi.lib<memcpy.c.obj>". This section contains decompression routines required for linker generated copy tables and C/C++ auto-initialization. Must ensure that this section is copied to run address before the C/C++ boot code is executed or is placed with single allocation specifier (ex. "> MEMORY").
warning #10278-D: LOAD placement specified for section "__TI___TI_zero_init_specialization:rts2800_fpu32_eabi.lib<copy_zero_init.c.obj>". This section contains decompression routines required for linker generated copy tables and C/C++ auto-initialization. Must ensure that this section is copied to run address before the C/C++ boot code is executed or is placed with single allocation specifier (ex. "> MEMORY").
warning #10278-D: LOAD placement specified for section ".text:decompress:ZI:__TI_zero_init_nomemset:rts2800_fpu32_eabi.lib<copy_zero_init.c.obj>". This section contains decompression routines required for linker generated copy tables and C/C++ auto-initialization. Must ensure that this section is copied to run address before the C/C++ boot code is executed or is placed with single allocation specifier (ex. "> MEMORY").
warning #10278-D: LOAD placement specified for section ".text:decompress:ZI:rts2800_fpu32_eabi.lib<copy_zero_init.c.obj>". This section contains decompression routines required for linker generated copy tables and C/C++ auto-initialization. Must ensure that this section is copied to run address before the C/C++ boot code is executed or is placed with single allocation specifier (ex. "> MEMORY").
warning #10278-D: LOAD placement specified for section ".text:rts2800_fpu32_eabi.lib<memset.c.obj>". This section contains decompression routines required for linker generated copy tables and C/C++ auto-initialization. Must ensure that this section is copied to run address before the C/C++ boot code is executed or is placed with single allocation specifier (ex. "> MEMORY").
warning #10278-D: LOAD placement specified for section ".text:decompress:lzss:rts2800_fpu32_eabi.lib<copy_decompress_lzss.c.obj>". This section contains decompression routines required for linker generated copy tables and C/C++ auto-initialization. Must ensure that this section is copied to run address before the C/C++ boot code is executed or is placed with single allocation specifier (ex. "> MEMORY").

undefined first referenced
symbol in file
--------- ----------------
__TI_SYSMEM_SIZE C:/ti/ccs1110/ccs/tools/compiler/ti-cgt-c2000_22.6.0.LTS/lib/rts2800_fpu32_eabi.lib<memory.c.obj>

      <logical_group id="lg-10" display="no" color="cyan">
         <name>Project1_Function</name>
         <load_address>0x8e0f8</load_address>
         <run_address>0x8e0f8</run_address>
         <size>0x8</size>
         <contents>
            <object_component_ref idref="oc-d8"/>
         </contents>
      </logical_group>

; This file is *auto-generated*. Do not edit. Mods risk being overwritten 
; Assembly file : F28002x_Project1_out_test_tmp.asm

	 .global	test
test	 .set	0x8e0f8

   .TI.apifunc : LOAD = FLASH_BANK0_SEC1415,
                  RUN = RAMLS7,
                  LOAD_START(ApifuncsLoadStart),
                  LOAD_SIZE(ApifuncsLoadSize),
                  LOAD_END(ApifuncsLoadEnd),
                  RUN_START(ApifuncsRunStart),
                  RUN_SIZE(ApifuncsRunSize),
                  RUN_END(ApifuncsRunEnd),
                  ALIGN(8)

#include "driverlib.h"
#include "device.h"
#include "test.h"

extern uint16_t ApifuncsLoadStart;
extern uint16_t ApifuncsLoadEnd;
extern uint16_t ApifuncsRunStart;


void MemCopy(uint16_t *SourceAddr, uint16_t* SourceEndAddr, uint16_t* DestAddr);


#pragma CODE_SECTION(test, ".TI.apifunc");

int R_Test1,R_Test2,R_Test3;

void main(void)
{
    // ApifuncsLoadStart   = (uint16_t*)0x0008E002;
    // ApifuncsLoadEnd     = (uint16_t*)0x0008E100;
    // ApifuncsRunStart    = (uint16_t*)0x0000B800;

    MemCopy(&ApifuncsLoadStart, &ApifuncsLoadEnd, &ApifuncsRunStart);

    R_Test1 = 123;
    R_Test2 = 456;

    for(;;)
    {
        R_Test3 = test(R_Test1,R_Test2);
    }
}

void MemCopy(uint16_t *SourceAddr, uint16_t* SourceEndAddr, uint16_t* DestAddr)
{
    while(SourceAddr < SourceEndAddr)
    {
       *DestAddr++ = *SourceAddr++;
    }
    return;
}

//
// SCI_Boot - This module is the main SCI boot routine.
//            It will load code via the SCI-A port.
//
//            It will return a entry point address back
//            to the system initialization routine which in turn calls
//            the ExitBoot routine.
//
uint32_t SCI_Boot(uint32_t bootMode)
{
    uint32_t entryAddress;
    uint16_t byteData;

    //
    // CPU1 Patch/Escape Point 13
    //
    entryAddress = CPU1BROM_TI_OTP_ESCAPE_POINT_13;
    if((entryAddress != 0xFFFFFFFFUL) &&
       (entryAddress != 0x00000000UL))
    {
        //
        // If OTP is programmed, then call OTP patch function
        //
        ((void (*)(void))entryAddress)();
    }

    //
    // Check if SCI is enabled on device or not
    //
   if(SysCtl_isPeripheralPresent(SYSCTL_PERIPH_PRESENT_SCIA) == false)
    {
        return(FLASH_ENTRY_POINT);
    }

    //
    // Assign GetWordData to the SCI-A version of the
    // function. GetWordData is a pointer to a function.
    //
    GetWordData = SCIA_GetWordData;

    //
    // Initialize the SCI-A port for communications
    // with the host.
    //

    //
    // Enable the SCI-A clocks
    //
    SysCtl_enablePeripheral(SYSCTL_PERIPH_CLK_SCIA);
    SysCtl_setLowSpeedClock(SYSCTL_LSPCLK_PRESCALE_4);

    EALLOW;
    HWREGH(SCIA_BASE + SCI_O_FFTX) = SCI_FFTX_SCIRST;

    //
    // 1 stop bit, No parity, 8-bit character
    // No loopback
    //
    HWREGH(SCIA_BASE + SCI_O_CCR) = (SCI_CONFIG_WLEN_8 | SCI_CONFIG_STOP_ONE);
    SCI_setParityMode(SCIA_BASE,SCI_CONFIG_PAR_NONE);

    //
    // Enable TX, RX, Use internal SCICLK
    //
    HWREGH(SCIA_BASE + SCI_O_CTL1) = (SCI_CTL1_TXENA | SCI_CTL1_RXENA);

    //
    // Disable RxErr, Sleep, TX Wake,
    // Disable Rx Interrupt, Tx Interrupt
    //
    HWREGB(SCIA_BASE + SCI_O_CTL2) = 0x0U;

    //
    // Relinquish SCI-A from reset and enable TX/RX
    //
    SCI_enableModule(SCIA_BASE);

    EDIS;

    //
    // GPIO INIT
    //
    SCIBOOT_configure_gpio(bootMode);

    //
    // CPU1 Patch/Escape Point 13
    //
    entryAddress = CPU1BROM_TI_OTP_ESCAPE_POINT_13;
    if((entryAddress != 0xFFFFFFFFUL) &&
       (entryAddress != 0x00000000UL))
    {
        //
        // If OTP is programmed, then call OTP patch function
        //
        ((void (*)(void))entryAddress)();
    }

    //
    // Perform autobaud lock with the host.
    // Note that if autobaud never occurs
    // the program will hang in this routine as there
    // is no timeout mechanism included.
    //
    SCI_lockAutobaud(SCIA_BASE);

    //
    // Read data
    //
    byteData = SCI_readCharBlockingNonFIFO(SCIA_BASE);

    //
    // Configure TX pin after autobaud lock
    // (Performed here to allow SCI to double as wait boot)
    //
    GPIO_setPadConfig(SCI_gpioTx,GPIO_PIN_TYPE_PULLUP);
    GPIO_setPinConfig(SCI_gpioTxPinConfig);

    //
    // Write data to request key
    //
    SCI_writeCharNonBlocking(SCIA_BASE,byteData);

    //
    // If the KeyValue was invalid, abort the load
    // and return the flash entry point.
    //
    if(SCIA_GetWordData() != BROM_EIGHT_BIT_HEADER)
    {
        return FLASH_ENTRY_POINT;
    }

    ReadReservedFn();

    entryAddress = GetLongData();

    CopyData();

    return entryAddress;
}

uint16fptr GetWordData; // GetWordData is a pointer to the function that
                        // interfaces to the peripheral. Each loader assigns
                        // this pointer to it's particular GetWordData function.

//
// CopyData - This routine copies multiple blocks of data from the host
//            to the specified RAM locations.  There is no error
//            checking on any of the destination addresses.
//            That is because it is assumed all addresses and block size
//            values are correct.
//
//            Multiple blocks of data are copied until a block
//            size of 00 00 is encountered.
//
void CopyData(void)
{
    struct HEADER {
        uint32_t DestAddr;        
        uint16_t BlockSize;
    } BlockHeader;

    uint16_t wordData;
    uint16_t i;

    //
    // Get the size in words of the first block
    //
    BlockHeader.BlockSize = (*GetWordData)();

    //
    // While the block size is > 0 copy the data
    // to the DestAddr.  There is no error checking
    // as it is assumed the DestAddr is a valid
    // memory location
    //
    while(BlockHeader.BlockSize != (uint16_t)0x0000U)
    {
        BlockHeader.DestAddr = GetLongData();

        for(i = 1; i <= BlockHeader.BlockSize; i++)
        {
            wordData = (*GetWordData)();
            *(uint16_t *)BlockHeader.DestAddr = wordData;
            BlockHeader.DestAddr+=1U;
        }

        //
        // Get the size of the next block
        //
        BlockHeader.BlockSize = (*GetWordData)();
    }

    return;
}

*(uint16_t *)BlockHeader.DestAddr = wordData;

MEMORY
{
   BEGIN           	: origin = 0x08D000, length = 0x000002
   BOOT_RSVD		: origin = 0x00000002, length = 0x00000126
   RAMM0           	: origin = 0x00000128, length = 0x000002D8
   RAMM1            : origin = 0x00000400, length = 0x000003F8     /* on-chip RAM block M1 */

   RAMLS7           : origin = 0x0000B800, length = 0x00000800
   RAMGS0           : origin = 0x0000C000, length = 0x000007F8

   BOOTROM          : origin = 0x003F0000, length = 0x00008000
   BOOTROM_EXT      : origin = 0x003F8000, length = 0x00007FC0
   RESET            : origin = 0x003FFFC0, length = 0x00000002

   FLASH_BANK0_SEC13   : origin = 0x08D002, length = 0x000FFE	/* on-chip Flash */
   FLASH_BANK0_SEC1415 : origin = 0x08E000, length = 0x002000	/* on-chip Flash */
}


SECTIONS
{
   codestart        : > BEGIN, ALIGN(8)
   .text            : > FLASH_BANK0_SEC13,   ALIGN(8)
   .cinit           : > FLASH_BANK0_SEC13,  ALIGN(8)
   .switch          : > FLASH_BANK0_SEC13,  ALIGN(8)
   .reset           : > RESET,                  TYPE = DSECT /* not used, */

   .stack           : > RAMM1

   .init_array      : > FLASH_BANK0_SEC13,  ALIGN(8)
   .bss             : > RAMLS7
   .bss:output      : > RAMLS7
   .bss:cio         : > RAMLS7
   .const           : > FLASH_BANK0_SEC13,  ALIGN(8)
   .data            : > RAMLS7
   .sysmem          : > RAMLS7


   Project1_Function
      {
         -l test.obj(.text)
      }
       load =  FLASH_BANK0_SEC1415,
       run  = RAMGS0,
       table(BINIT),
       ALIGN(8)
   .binit         : > FLASH_BANK0_SEC1415
}

      <object_component id="oc-d9">
         <name>.text:test</name>
         <load_address>0x8e000</load_address>
         <run_address>0xc000</run_address>
         <size>0x8</size>
         <input_file_ref idref="fl-6"/>
      </object_component>

#include "driverlib.h"
#include "device.h"
#include "test.h"

uint16_t* ApifuncsLoadStart;
uint16_t* ApifuncsLoadEnd;
uint16_t* ApifuncsRunStart;


void MemCopy(uint16_t *SourceAddr, uint16_t* SourceEndAddr, uint16_t* DestAddr);


#pragma CODE_SECTION(test, ".TI.apifunc");

int R_Test1,R_Test2,R_Test3;

void main(void)
{
    ApifuncsLoadStart   = (uint16_t*)0x0008E000;
    ApifuncsLoadEnd     = (uint16_t*)0x0008E100;
    ApifuncsRunStart    = (uint16_t*)0x0000C000;

    MemCopy(ApifuncsLoadStart, ApifuncsLoadEnd, ApifuncsRunStart);

    R_Test1 = 123;
    R_Test2 = 456;

    for(;;)
    {
        R_Test3 = test(R_Test1,R_Test2);
    }
}

void MemCopy(uint16_t *SourceAddr, uint16_t* SourceEndAddr, uint16_t* DestAddr)
{
    while(SourceAddr < SourceEndAddr)
    {
       *DestAddr++ = *SourceAddr++;
    }
    return;
}