adsp-ts201_ovl_mp_c.ldf

基于TS201 Sets up a skeleton overlay system in C

        } >M8DataA

        data2a
        {
            INPUT_SECTIONS( $DATA_OBJECTS_DSPA(data2a) $LIBRARIES(data2a) )
        } >M2DataA

        data2b
        {
            INPUT_SECTIONS( $DATA_OBJECTS_DSPA(data2b) $LIBRARIES(data2b) )
        } >M2DataB

        data4a
        {
            INPUT_SECTIONS( $DATA_OBJECTS_DSPA(data4a) $LIBRARIES(data4a) )
        } >M4DataA

        data4b
        {
            INPUT_SECTIONS( $DATA_OBJECTS_DSPA(data4b) $LIBRARIES(data4b) )
        } >M4DataB

        data6a
        {
            INPUT_SECTIONS( $DATA_OBJECTS_DSPA(data6a) $LIBRARIES(data6a) )
        } >M6DataA

        data6b
        {
            INPUT_SECTIONS( $DATA_OBJECTS_DSPA(data6b) $LIBRARIES(data6b) )
        } >M6DataB

        data8a
        {
            INPUT_SECTIONS( $DATA_OBJECTS_DSPA(data8a) $LIBRARIES(data8a) )
        } >M8DataA

        data8b
        {
            INPUT_SECTIONS( $DATA_OBJECTS_DSPA(data8b) $LIBRARIES(data8b) )
        } >M8DataB

        data10a
        {
            INPUT_SECTIONS( $DATA_OBJECTS_DSPA(data10a) $LIBRARIES(data10a) )
        } >M10DataA

        data10b
        {
            INPUT_SECTIONS( $DATA_OBJECTS_DSPA(data10b) $LIBRARIES(data10b) )
        } >M10DataB

        // Allocate stacks for the application. Note that stacks
        // grow downward, and must be quad-word aligned. This means
        // that the location just after the highest word of the stack
        // is quad-word aligned (evenly divisible by 4). There are two
        // labels for each stack: "*_base" is the location just ABOVE
        // the top of the stack, and "*_limit" is the lowest word that
        // is part of the stack. Each stack occupies all of its own
        // memory block.

        jstackseg
        {
            ldf_jstack_limit = .;
            ldf_jstack_base = . + MEMORY_SIZEOF(M4Stack);
        } >M4Stack

        kstackseg
        {
            ldf_kstack_limit = .;
            ldf_kstack_base = . + MEMORY_SIZEOF(M6Stack);
        } >M6Stack

        // The default heap occupies its own memory block
        defheapseg
        {
            ldf_defheap_base = .;
            ldf_defheap_size = MEMORY_SIZEOF(M4Heap);
        } >M4Heap

    }
}


PROCESSOR p1
{
          RESOLVE( _____system_start, 0x00000000 )
          KEEP( _____system_start, _main, ___ctor_end, __sw_handler_ctor )

    OUTPUT( $COMMAND_LINE_OUTPUT_DIRECTORY\DSPB.dxe )

    SECTIONS
    {
        code
        {
            FILL(0xb3c00000)
            INPUT_SECTION_ALIGN(4)	    
            INPUT_SECTIONS($PROGRAM_OBJECTS_DSPB(program) $LIBRARIES(program))
			// The next line adds 10 nops to the end of the code section.
            // This is required on TS201 to prevent uninitialised memory
            // getting into the pipeline.
            . = . + 10;
        } >M0Code

        
        // Provide support for initialization, including C++ static
        // initialization. This section builds a table of
        // initialization function pointers. These functions are
        // called in order before the main routine is entered. The
        // order is determined by the linker section in which the
        // function pointer has been defined: the C library uses
        // ctor0 through ctor4, and the compiler uses ctor for C++
        // static initializers. The C library uses several sections
        // to satisfy ordering requirements among initializers.
        // The ctorl marker terminates this section.

        ctor
        {
            INPUT_SECTIONS( $DATA_OBJECTS_DSPB(ctor0) $LIBRARIES(ctor0)  )
            INPUT_SECTIONS( $DATA_OBJECTS_DSPB(ctor1) $LIBRARIES(ctor1)  )
            INPUT_SECTIONS( $DATA_OBJECTS_DSPB(ctor2) $LIBRARIES(ctor2)  )
            INPUT_SECTIONS( $DATA_OBJECTS_DSPB(ctor3) $LIBRARIES(ctor3)  )
            INPUT_SECTIONS( $DATA_OBJECTS_DSPB(ctor4) $LIBRARIES(ctor4)  )
            INPUT_SECTIONS( $DATA_OBJECTS_DSPB(ctor)  $LIBRARIES(ctor)  )
            INPUT_SECTIONS( $DATA_OBJECTS_DSPB(ctorl) $LIBRARIES(ctorl)  )
        } >M4DataA

        // Table containing heap segment descriptors
        heaptab
        {
            INPUT_SECTIONS( $DATA_OBJECTS_DSPB(heaptab) $LIBRARIES(heaptab) )
        } >M4DataA

        // Allocate stacks for the application. Note that stacks
        // grow downward, and must be quad-word aligned. This means
        // that the location just after the highest word of the stack
        // is quad-word aligned (evenly divisible by 4). There are two
        // labels for each stack: "*_base" is the location just ABOVE
        // the top of the stack, and "*_limit" is the lowest word that
        // is part of the stack. Each stack occupies all of its own
        // memory block.

        data1
        {
            INPUT_SECTIONS($DATA_OBJECTS_DSPB(data1) $LIBRARIES(data1))
        } >M4DataA

        bsz_init
        {
            INPUT_SECTIONS( $DATA_OBJECTS_DSPB(bsz_init) $LIBRARIES(bsz_init))
        } >M4DataA
    
        .meminit {} >M4DataA
    
        bsz ZERO_INIT
        {
            INPUT_SECTIONS( $DATA_OBJECTS_DSPB(bsz) $LIBRARIES(bsz) )
        } >M4DataA

        MEM_ARGV
        {
            INPUT_SECTIONS( $DATA_OBJECTS_DSPB(MEM_ARGV) $LIBRARIES(MEM_ARGV) )
        } >M4DataA


        data2
        {
            INPUT_SECTIONS($DATA_OBJECTS_DSPB(data2) $LIBRARIES(data2))
        } >M8DataA



        data2a
        {
            INPUT_SECTIONS( $DATA_OBJECTS_DSPB(data2a) $LIBRARIES(data2a) )
        } >M2DataA

        data2b
        {
            INPUT_SECTIONS( $DATA_OBJECTS_DSPB(data2b) $LIBRARIES(data2b) )
        } >M2DataB

        data4a
        {
            INPUT_SECTIONS( $DATA_OBJECTS_DSPB(data4a) $LIBRARIES(data4a) )
        } >M4DataA

        data4b
        {
            INPUT_SECTIONS( $DATA_OBJECTS_DSPB(data4b) $LIBRARIES(data4b) )
        } >M4DataB

        data6a
        {
            INPUT_SECTIONS( $DATA_OBJECTS_DSPB(data6a) $LIBRARIES(data6a) )
        } >M6DataA

        data6b
        {
            INPUT_SECTIONS( $DATA_OBJECTS_DSPB(data6b) $LIBRARIES(data6b) )
        } >M6DataB

        data8a
        {
            INPUT_SECTIONS( $DATA_OBJECTS_DSPB(data8a) $LIBRARIES(data8a) )
        } >M8DataA

        data8b
        {
            INPUT_SECTIONS( $DATA_OBJECTS_DSPB(data8b) $LIBRARIES(data8b) )
        } >M8DataB

        data10a
        {
            INPUT_SECTIONS( $DATA_OBJECTS_DSPB(data10a) $LIBRARIES(data10a) )
        } >M10DataA

        data10b
        {
            INPUT_SECTIONS( $DATA_OBJECTS_DSPB(data10b) $LIBRARIES(data10b) )
        } >M10DataB

        // Allocate stacks for the application. Note that stacks
        // grow downward, and must be quad-word aligned. This means
        // that the location just after the highest word of the stack
        // is quad-word aligned (evenly divisible by 4). There are two
        // labels for each stack: "*_base" is the location just ABOVE
        // the top of the stack, and "*_limit" is the lowest word that
        // is part of the stack. Each stack occupies all of its own
        // memory block.

        jstackseg
        {
            ldf_jstack_limit = .;
            ldf_jstack_base = . + MEMORY_SIZEOF(M4Stack);
        } >M4Stack

        kstackseg
        {
            ldf_kstack_limit = .;
            ldf_kstack_base = . + MEMORY_SIZEOF(M6Stack);
        } >M6Stack

        // The default heap occupies its own memory block
        defheapseg
        {
            ldf_defheap_base = .;
            ldf_defheap_size = MEMORY_SIZEOF(M4Heap);
        } >M4Heap

    }
}