adsp-ts201.ldf

TS201 FFT程序

        // 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
        {
            FORCE_CONTIGUITY
            INPUT_SECTIONS( $OBJECTS(ctor0) $LIBRARIES(ctor0)  )
            INPUT_SECTIONS( $OBJECTS(ctor1) $LIBRARIES(ctor1)  )
            INPUT_SECTIONS( $OBJECTS(ctor2) $LIBRARIES(ctor2)  )
            INPUT_SECTIONS( $OBJECTS(ctor3) $LIBRARIES(ctor3)  )
            INPUT_SECTIONS( $OBJECTS(ctor4) $LIBRARIES(ctor4)  )
            INPUT_SECTIONS( $OBJECTS(ctor)  $LIBRARIES(ctor)  )
            INPUT_SECTIONS( $OBJECTS(ctorl) $LIBRARIES(ctorl)  )
        } >M4DataA

        // Table containing heap segment descriptors
        heaptab
        {
            INPUT_SECTIONS( $OBJECTS(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( $OBJS_LIBS_INTERNAL(data1))
            INPUT_SECTIONS( $OBJS_LIBS_NOT_EXTERNAL(data1))
            INPUT_SECTIONS( $OBJECTS(data1) $LIBRARIES(data1) )
        } >M4DataA

        bsz_init
        {
            INPUT_SECTIONS( $OBJS_LIBS_INTERNAL(bsz_init))
            INPUT_SECTIONS( $OBJS_LIBS_NOT_EXTERNAL(bsz_init))
            INPUT_SECTIONS( $OBJECTS(bsz_init) $LIBRARIES(bsz_init))
        } >M4DataA
    
        .meminit {} >M4DataA
    
        bsz ZERO_INIT
        {
            INPUT_SECTIONS( $OBJS_LIBS_INTERNAL(bsz))
            INPUT_SECTIONS( $OBJS_LIBS_NOT_EXTERNAL(bsz))
            INPUT_SECTIONS( $OBJECTS(bsz) $LIBRARIES(bsz) )
        } >M4DataA

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

#ifdef __cplusplus
        .gdt
        {
          FORCE_CONTIGUITY
          INPUT_SECTIONS( $OBJECTS(.gdt) $LIBRARIES(.gdt) )
          INPUT_SECTIONS( $OBJECTS(.gdtl) $LIBRARIES(.gdtl) )
        } > M2DataA

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

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

        .edt
        {
          INPUT_SECTIONS( $OBJECTS(.edt) $LIBRARIES(.edt) )
          INPUT_SECTIONS( $OBJECTS(.rtti) $LIBRARIES(.rtti) )
        } > M2DataA

        vtbl
        {
          INPUT_SECTIONS( $OBJECTS(vtbl) $LIBRARIES(vtbl) )
        } > M2DataA
#endif

        data2
        {
            INPUT_SECTIONS( $OBJS_LIBS_INTERNAL(data2))
            INPUT_SECTIONS( $OBJS_LIBS_NOT_EXTERNAL(data2))
            INPUT_SECTIONS( $OBJECTS(data2) $LIBRARIES(data2) )
        } >M8DataA
        handshake
        {
            INPUT_SECTIONS( $OBJS_LIBS_INTERNAL(handshake))
            INPUT_SECTIONS( $OBJS_LIBS_NOT_EXTERNAL(handshake))
            INPUT_SECTIONS( $OBJECTS(data2) $LIBRARIES(handshake) )
        } >HANDSHAKE

        data2a
        {
            INPUT_SECTIONS( $OBJS_LIBS_INTERNAL(data2a))
            INPUT_SECTIONS( $OBJS_LIBS_NOT_EXTERNAL(data2a))
            INPUT_SECTIONS( $OBJECTS(data2a) $LIBRARIES(data2a) )
        } >M2DataA

        data2b
        {
            INPUT_SECTIONS( $OBJS_LIBS_INTERNAL(data2b))
            INPUT_SECTIONS( $OBJS_LIBS_NOT_EXTERNAL(data2b))
            INPUT_SECTIONS( $OBJECTS(data2b) $LIBRARIES(data2b) )
        } >M2DataB

        data4a
        {
            INPUT_SECTIONS( $OBJS_LIBS_INTERNAL(data4a))
            INPUT_SECTIONS( $OBJS_LIBS_NOT_EXTERNAL(data4a))
            INPUT_SECTIONS( $OBJECTS(data4a) $LIBRARIES(data4a) )
        } >M4DataA

        data4b
        {
        // 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.
 
            RESERVE(heaps_and_stack, heaps_and_stack_length = 16K)
            INPUT_SECTIONS( $OBJECTS(data4b) $LIBRARIES(data4b) )
            RESERVE_EXPAND(heaps_and_stack, heaps_and_stack_length)
            ldf_jstack_end = heaps_and_stack;
            ldf_jstack_base = (ldf_jstack_end + (((heaps_and_stack_length * 14K) / 16K) - 4)) & 0xfffffffc;
            ldf_jstack_limit = ldf_jstack_base - ldf_jstack_end;
            ldf_defheap_base = ldf_jstack_base + 4;
            ldf_defheap_end = (ldf_defheap_base + (((heaps_and_stack_length * 2K) / 16K) - 4)) & 0xfffffffc;
            ldf_defheap_size = ldf_defheap_end - ldf_defheap_base;
        } >M4DataB

        data6a
        {
            RESERVE(heaps_and_stack_data6a, heaps_and_stack_length_data6a = 62K)
            INPUT_SECTIONS( $OBJECTS(data6a) $LIBRARIES(data6a) )
            RESERVE_EXPAND(heaps_and_stack_data6a, heaps_and_stack_length_data6a)
            ldf_kstack_end = heaps_and_stack_data6a;
            ldf_kstack_base = (ldf_kstack_end + (((heaps_and_stack_length_data6a * 14K) / 62K) - 4)) & 0xfffffffc;
            ldf_kstack_limit = ldf_kstack_base - ldf_kstack_end;
            ldf_altheap_base = ldf_kstack_base + 4;
            ldf_altheap_end = (ldf_altheap_base + (((heaps_and_stack_length_data6a * 48K) / 62K) - 4)) & 0xfffffffc;
            ldf_altheap_size = ldf_altheap_end - ldf_altheap_base;
        } >M6DataA

        data8a
        {
            INPUT_SECTIONS( $OBJS_LIBS_INTERNAL(data8a))
            INPUT_SECTIONS( $OBJS_LIBS_NOT_EXTERNAL(data8a))
            INPUT_SECTIONS( $OBJECTS(data8a) $LIBRARIES(data8a) )
        } >M8DataA

        data8b
        {
            INPUT_SECTIONS( $OBJS_LIBS_INTERNAL(data8b))
            INPUT_SECTIONS( $OBJS_LIBS_NOT_EXTERNAL(data8b))
            INPUT_SECTIONS( $OBJECTS(data8b) $LIBRARIES(data8b) )
        } >M8DataB

        data10a
        {
            INPUT_SECTIONS( $OBJS_LIBS_INTERNAL(data10a))
            INPUT_SECTIONS( $OBJS_LIBS_NOT_EXTERNAL(data10a))
            INPUT_SECTIONS( $OBJECTS(data10a) $LIBRARIES(data10a) )
        } >M10DataA

        data10b
        {
            INPUT_SECTIONS( $OBJS_LIBS_INTERNAL(data10b))
            INPUT_SECTIONS( $OBJS_LIBS_NOT_EXTERNAL(data10b))
            INPUT_SECTIONS( $OBJECTS(data10b) $LIBRARIES(data10b) )
        } >M10DataB
    }
}