adsp-21262_c.ldf

来自「ADI 公司的DSP ADSP21262 EZ-KIT LITE开发板的全部源代」· LDF 代码 · 共 244 行

#define FILE_DATA_WIDTH 16
ARCHITECTURE(ADSP-21262)

//
//   ADSP-21262 Memory Map:
//   ------------------------------------------------
//                    0x0000 0000 to 0x0003 FFFF  IOP Regs
//           Block0   0x0004 0000 to 0x0004 3FFF  Long word (64) Space (1MB RAM)
//           Block0   0x0004 4000 to 0x0005 7FFF  Internal Memory (Reserved 5MB)
//           Block0   0x0005 8000 to 0x0005 FFFF  Long word (64) Space (2MB ROM)

//           Block1   0x0006 0000 to 0x0006 3FFF  Long word (64) Space (1MB RAM)
//           Block1   0x0006 4000 to 0x0007 7FFF  Internal Memory (Reserved 5MB)
//           Block1   0x0007 8000 to 0x0007 FFFF  Long word (64) Space (2MB ROM)

//           Block0   0x0008 0000 to 0x0008 7FFF  Normal word (32) Space (1MB RAM)
//           Block0   0x0008 8000 to 0x000A FFFF  Internal Memory (Reserved 5MB)
//           Block0   0x000B 0000 to 0x000B FFFF  Normal word (32) Space (2MB ROM)
//   ------------------------------------------------
//                    0x000A 0000 to 0x000A AAAA  48-bit addresses
//   ------------------------------------------------
//           Block1   0x000C 0000 to 0x000C 7FFF  Normal word (32) Space (1MB RAM)
//           Block1   0x000C 8000 to 0x000E FFFF  Internal Memory (Reserved 5MB)
//           Block1   0x000F 0000 to 0x000F FFFF  Normal word (32) Space (2MB ROM)
//   ------------------------------------------------
//                    0x000E 0000 to 0x000E AAAA  48-bit addresses
//   ------------------------------------------------
//           Block0   0x0010 0000 to 0x0010 FFFF  Short word (16) Space (1MB RAM)
//           Block0   0x0011 0000 to 0x0015 FFFF  Internal Memory (Reserved 5MB)
//           Block0   0x0011 0000 to 0x0015 FFFF  Internal Memory (Reserved 5MB)
//           Block0   0x0016 0000 to 0x0017 FFFF  Short word (16) Space (2MB ROM)

//           Block1   0x0018 0000 to 0x0018 FFFF  Short word (16) Space (1MB RAM)
//           Block1   0x0019 0000 to 0x001D FFFF  Internal Memory (Reserved 5MB)
//           Block1   0x001E 0000 to 0x001F FFFF  Short word (16) Space (2MB ROM)

//   ------------------------------------------------
//   External memory  0x0100 0000 to 0x02FF FFFF
//   ------------------------------------------------

// This linker description file allocates:
//         Internal 256 words of run-time header in memory block 0
//                  256 words of initialization code in memory block 0
//                  16K words of C code space in memory block 0
//                   7K words of C PM data space in memory block 0
//                  32K words of C DM data space in memory block 1
//                   8K words of C heap space in memory block 1
//                   8K words of C stack space in memory block 1

SEARCH_DIR( $ADI_DSP\212xx\lib )

#ifdef _ADI_THREADS
#ifdef __ADI_LIBEH__
$LIBRARIES = libehmt.dlb, libc26xmt.dlb, libiomt.dlb, libdsp26x.dlb;
#else
$LIBRARIES = libc26xmt.dlb, libiomt.dlb, libdsp26x.dlb;
#endif
#else
#ifdef __ADI_LIBEH__
$LIBRARIES = libeh.dlb, libc26x.dlb, libio.dlb, libdsp26x.dlb;
#else
$LIBRARIES = libc26x.dlb, libio.dlb, libdsp26x.dlb;
#endif
#endif

// Libraries from the command line are included in COMMAND_LINE_OBJECTS.
#ifndef EZKIT_MONITOR
#ifdef __ADI_LIBEH__
#define CRT_HDR 262_hdr_adamagic.doj
#else
#define CRT_HDR 262_hdr.doj
#endif
#else
#define CRT_HDR 262_hdr_ezkit.doj
#endif
$OBJECTS = CRT_HDR, $COMMAND_LINE_OBJECTS;

MEMORY
{
#ifdef __EZKIT_LICENSE_RESTRICTION_SHARC__

  // Only 10K available for PM
  // Use the space unavailable to PM as DM
    mem_rth  { TYPE(PM RAM) START(0x00080000) END(0x000800ff) WIDTH(48) }
    mem_init { TYPE(PM RAM) START(0x00080100) END(0x000801ff) WIDTH(48) }
    mem_pmco { TYPE(PM RAM) START(0x00080200) END(0x000825ff) WIDTH(48) }
    mem_pmda { TYPE(PM RAM) START(0x00083900) END(0x00083DAA) WIDTH(32) }
    mem_dm32 { TYPE(DM RAM) START(0x00083DAB) END(0x00087FFF) WIDTH(32) }

#else

    mem_rth  { TYPE(PM RAM) START(0x00080000) END(0x000800ff) WIDTH(48) }
    mem_init { TYPE(PM RAM) START(0x00080100) END(0x000801ff) WIDTH(48) }
    mem_int_code { TYPE(PM RAM) START(0x00080200) END(0x00080287) WIDTH(48) }
    mem_pmco { TYPE(PM RAM) START(0x00080288) END(0x000841ff) WIDTH(48) }
    mem_pmda { TYPE(PM RAM) START(0x00086300) END(0x00087fff) WIDTH(32) }

#endif

    mem_dmda { TYPE(DM RAM) START(0x000c0000) END(0x000c3fff) WIDTH(32) }
    mem_heap { TYPE(DM RAM) START(0x000c4000) END(0x000c5fff) WIDTH(32) }
    mem_stak { TYPE(DM RAM) START(0x000c6000) END(0x000c7fff) WIDTH(32) }

    mem_ext8A { TYPE(DM RAM DMAONLY) START(0x01200000) END(0x0121FFFF) WIDTH(8) }
    mem_ext8B { TYPE(DM RAM DMAONLY) START(0x01220000) END(0x0123FFFF) WIDTH(8) }
    mem_ext8C { TYPE(DM RAM DMAONLY) START(0x01240000) END(0x0125FFFF) WIDTH(8) }
    mem_ext8D { TYPE(DM RAM DMAONLY) START(0x01260000) END(0x0127FFFF) WIDTH(8) }


}


PROCESSOR p0
{
    KEEP( _main,___ctor_NULL_marker,___lib_end_of_heap_descriptions )
    LINK_AGAINST( $COMMAND_LINE_LINK_AGAINST)
    OUTPUT( $COMMAND_LINE_OUTPUT_FILE )

    SECTIONS
    {
        // .text output section
        dxe_rth
        {
            INPUT_SECTIONS( $OBJECTS(seg_rth) $LIBRARIES(seg_rth))
        } >mem_rth

        dxe_init
        {
            ldf_seginit_space = . ;
            INPUT_SECTIONS( $OBJECTS(seg_init) $LIBRARIES(seg_init))
        } >mem_init

#ifdef __EZKIT_LICENSE_RESTRICTION_SHARC__

        dxe_int_code
        {
            INPUT_SECTIONS( $OBJECTS(seg_int_code) $LIBRARIES(seg_int_code))
        } >mem_pmco

#else
        dxe_int_code
        {
            INPUT_SECTIONS( $OBJECTS(seg_int_code) $LIBRARIES(seg_int_code))
        } >mem_int_code
#endif

        dxe_pmco
        {
            INPUT_SECTIONS( $OBJECTS(seg_pmco) $LIBRARIES(seg_pmco))
        } >mem_pmco

        dxe_pmda
        {
            INPUT_SECTIONS( $OBJECTS(seg_pmda) $LIBRARIES(seg_pmda))
        } >mem_pmda


        dxe_dmda
        {
            INPUT_SECTIONS( $OBJECTS(seg_dmda) $LIBRARIES(seg_dmda))
        } > mem_dmda

#ifdef __EZKIT_LICENSE_RESTRICTION_SHARC__
        //When using an EZkit license, only 10K PM words are allowed. The extra space left over in Block 0 which is defined
        //as PM for full licenses is declared as 32-bit DM data by default for the EZkit license. Make note of this difference
        //when switching from an EZkit license to a full license while using the default LDF files.

        dxe_dm32
        {
            INPUT_SECTIONS( $OBJECTS(seg_dm32) $LIBRARIES(seg_dm32) )
        } >mem_dm32

#endif

        dxe_ext8A //SHT_NOBITS              //For debug purposes, after loading the external segment once, use the SHT_NOBITS
        {                                   //command in the LDF to avoid the lengthy process of initializing external memory via the emulator
        INPUT_SECTIONS( $OBJECTS(seg_extA)) //as you debug. Be sure to rebuild without SHT_NOBITS after debug or when external data has changed.
            PACKING(5  B0 B1 B2 B4 B5 B0 B0 B0 B3 B0)
        } > mem_ext8A


        dxe_ext8B //SHT_NOBITS              //For debug purposes, after loading the external segment once, use the SHT_NOBITS
        {                                   //command in the LDF to avoid the lengthy process of initializing external memory via the emulator
            INPUT_SECTIONS( $OBJECTS(seg_extB)) //as you debug. Be sure to rebuild without SHT_NOBITS after debug or when external data has changed.
            PACKING(5  B0 B1 B2 B4 B5 B0 B0 B0 B3 B0)
        } > mem_ext8B


        dxe_ext8C //SHT_NOBITS              //For debug purposes, after loading the external segment once, use the SHT_NOBITS
        {                                   //command in the LDF to avoid the lengthy process of initializing external memory via the emulator
            INPUT_SECTIONS( $OBJECTS(seg_extC)) //as you debug. Be sure to rebuild without SHT_NOBITS after debug or when external data has changed.
            PACKING(5  B0 B1 B2 B4 B5 B0 B0 B0 B3 B0)
        } > mem_ext8C

        dxe_ext8D //SHT_NOBITS              //For debug purposes, after loading the external segment once, use the SHT_NOBITS
        {                                   //command in the LDF to avoid the lengthy process of initializing external memory via the emulator
            INPUT_SECTIONS( $OBJECTS(seg_extD)) //as you debug. Be sure to rebuild without SHT_NOBITS after debug or when external data has changed.
            PACKING(5  B0 B1 B2 B4 B5 B0 B0 B0 B3 B0)
        } > mem_ext8D



#ifdef __ADI_LIBEH__
    .gdt
    {
      INPUT_SECTIONS( $OBJECTS(.gdt) $LIBRARIES(.gdt))
    } > mem_dmda

    .frt
    {
      INPUT_SECTIONS( $OBJECTS(.frt) $LIBRARIES(.frt))
    } > mem_dmda

    .cht
    {
      INPUT_SECTIONS( $OBJECTS(.cht) $LIBRARIES(.cht))
    } > mem_dmda

    .edt
    {
      INPUT_SECTIONS( $OBJECTS(.edt) $LIBRARIES(.edt))
    } > mem_dmda
#endif

        stackseg
        {

            // allocate a stack for the application
            ldf_stack_space = .;
            ldf_stack_length = MEMORY_SIZEOF(mem_stak);
        } > mem_stak

        heap
        {
            // allocate a heap for the application
            ldf_heap_space = .;
            ldf_heap_length = MEMORY_SIZEOF(mem_heap);
            ldf_heap_end = ldf_heap_space + ldf_heap_length - 1;
        } > mem_heap

    }
}