vdk-ts201.ldf

Visual DSP++ VDK的应用举例

    sec_INT_DMA6    { INPUT_SECTIONS( $OBJS(seg_INT_DMA6_64)  $LIBS(seg_INT_DMA6_64) ) } > mem4_IVDMA6
    sec_INT_DMA7    { INPUT_SECTIONS( $OBJS(seg_INT_DMA7_64)  $LIBS(seg_INT_DMA7_64) ) } > mem4_IVDMA7
    sec_INT_DMA8    { INPUT_SECTIONS( $OBJS(seg_INT_DMA8_64)  $LIBS(seg_INT_DMA8_64) ) } > mem4_IVDMA8
    sec_INT_DMA9    { INPUT_SECTIONS( $OBJS(seg_INT_DMA9_64)  $LIBS(seg_INT_DMA9_64) ) } > mem4_IVDMA9
    sec_INT_DMA10   { INPUT_SECTIONS( $OBJS(seg_INT_DMA10_64)  $LIBS(seg_INT_DMA10_64) ) } > mem4_IVDMA10
    sec_INT_DMA11   { INPUT_SECTIONS( $OBJS(seg_INT_DMA11_64)  $LIBS(seg_INT_DMA11_64) ) } > mem4_IVDMA11
    sec_INT_DMA12   { INPUT_SECTIONS( $OBJS(seg_INT_DMA12_64)  $LIBS(seg_INT_DMA12_64) ) } > mem4_IVDMA12
    sec_INT_DMA13   { INPUT_SECTIONS( $OBJS(seg_INT_DMA13_64)  $LIBS(seg_INT_DMA13_64) ) } > mem4_IVDMA13
    sec_INT_IRQ0    { INPUT_SECTIONS( $OBJS(seg_INT_IRQ0_64)  $LIBS(seg_INT_IRQ0_64) ) } > mem4_IVIRQ0
    sec_INT_IRQ1    { INPUT_SECTIONS( $OBJS(seg_INT_IRQ1_64)  $LIBS(seg_INT_IRQ1_64) ) } > mem4_IVIRQ1
    sec_INT_IRQ2    { INPUT_SECTIONS( $OBJS(seg_INT_IRQ2_64)  $LIBS(seg_INT_IRQ2_64) ) } > mem4_IVIRQ2
    sec_INT_IRQ3    { INPUT_SECTIONS( $OBJS(seg_INT_IRQ3_64)  $LIBS(seg_INT_IRQ3_64) ) } > mem4_IVIRQ3
    sec_INT_VIRPT   { INPUT_SECTIONS( $OBJS(seg_INT_VIRPT_64)  $LIBS(seg_INT_VIRPT_64) ) } > mem4_VIRPT
    sec_INT_BUSLOCK   { INPUT_SECTIONS( $OBJS(seg_INT_BUSLOCK_64)  $LIBS(seg_INT_BUSLOCK_64) ) } > mem4_IVBUSLOCK
    sec_INT_TIMER0H	{ INPUT_SECTIONS( $OBJS(seg_INT_TIMER0H_64)  $LIBS(seg_INT_TIMER0H_64) ) } > mem4_IVTIMER0H
    sec_INT_TIMER1H	{ INPUT_SECTIONS( $OBJS(seg_INT_TIMER1H_64)  $LIBS(seg_INT_TIMER1H_64) ) } > mem4_IVTIMER1H
    sec_INT_HWERR  	{ INPUT_SECTIONS( $OBJS(seg_INT_HWERR_64)  $LIBS(seg_INT_HWERR_64) ) } > mem4_IVHWERR
 
    sec_code
    {
        FILL(0xb3c00000)
        INPUT_SECTION_ALIGN(4) 
        INPUT_SECTIONS( $OBJS(program) $LIBS(program) ) 
        INPUT_SECTIONS( $LIBS(VDK_ISR_code) ) 
        // 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;
    } > mem0_Program

    sec_data1
    {
	INPUT_SECTIONS( $OBJS_LIBS_INTERNAL(data1))
	INPUT_SECTIONS( $OBJS_LIBS_NOT_EXTERNAL(data1))
        INPUT_SECTIONS( $OBJS(data1) $LIBS(data1) )
    } > mem4_DataA

    sec_data2
    {
	INPUT_SECTIONS( $OBJS_LIBS_INTERNAL(data2))
	INPUT_SECTIONS( $OBJS_LIBS_NOT_EXTERNAL(data2))
        INPUT_SECTIONS( $OBJS(data2) $LIBS(data2) )
    } > mem8_DataA

    data1a
    {
	INPUT_SECTIONS( $OBJS_LIBS_INTERNAL(data1a))
	INPUT_SECTIONS( $OBJS_LIBS_NOT_EXTERNAL(data1a))
        INPUT_SECTIONS( $OBJS(data1a) $LIBS(data1a) )
    } >mem2_DataA

    data1b
    {
	INPUT_SECTIONS( $OBJS_LIBS_INTERNAL(data1b))
	INPUT_SECTIONS( $OBJS_LIBS_NOT_EXTERNAL(data1b))
        INPUT_SECTIONS( $OBJS(data1b) $LIBS(data1b) )
    } >mem2_DataB

    data2a
    {
	INPUT_SECTIONS( $OBJS_LIBS_INTERNAL(data2a))
	INPUT_SECTIONS( $OBJS_LIBS_NOT_EXTERNAL(data2a))
        INPUT_SECTIONS( $OBJS(data2a) $LIBS(data2a) )
    } >mem4_DataA

    data2b
    {
	INPUT_SECTIONS( $OBJS_LIBS_INTERNAL(data2b))
	INPUT_SECTIONS( $OBJS_LIBS_NOT_EXTERNAL(data2b))
        INPUT_SECTIONS( $OBJS(data2b) $LIBS(data2b) )
    } >mem4_DataB

    data3a
    {
	INPUT_SECTIONS( $OBJS_LIBS_INTERNAL(data3a))
	INPUT_SECTIONS( $OBJS_LIBS_NOT_EXTERNAL(data3a))
        INPUT_SECTIONS( $OBJS(data3a) $LIBS(data3a) )
    } >mem6_DataA

    data3b
    {
	INPUT_SECTIONS( $OBJS_LIBS_INTERNAL(data3b))
	INPUT_SECTIONS( $OBJS_LIBS_NOT_EXTERNAL(data3b))
        INPUT_SECTIONS( $OBJS(data3b) $LIBS(data3b) )
    } >mem6_DataB

 // 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.

    data4a
    {
	INPUT_SECTIONS( $OBJS_LIBS_INTERNAL(data4a))
	INPUT_SECTIONS( $OBJS_LIBS_NOT_EXTERNAL(data4a))
        INPUT_SECTIONS( $OBJS(ctor0) $LIBS(ctor0) )
        INPUT_SECTIONS( $OBJS(ctor1) $LIBS(ctor1) )
        INPUT_SECTIONS( $OBJS(ctor2) $LIBS(ctor2) )
        INPUT_SECTIONS( $OBJS(ctor3) $LIBS(ctor3) )
        INPUT_SECTIONS( $OBJS(ctor4) $LIBS(ctor4) )
        INPUT_SECTIONS( $OBJS(ctor) $LIBS(ctor) )
        INPUT_SECTIONS( $LIBS(ctorl) )
        INPUT_SECTIONS( $OBJS(heaptab) $LIBS(heaptab) )
	INPUT_SECTIONS( $OBJS_LIBS_INTERNAL(bsz_init))
	INPUT_SECTIONS( $OBJS_LIBS_NOT_EXTERNAL(bsz_init))
        INPUT_SECTIONS( $OBJS(.gdt) $LIBS(.gdt) )
        INPUT_SECTIONS( $OBJS(.gdtl) $LIBS(.gdtl) )
        INPUT_SECTIONS( $OBJS(.frt) $LIBS(.frt) )
        INPUT_SECTIONS( $OBJS(.frtl) $LIBS(.frtl) )
        INPUT_SECTIONS( $OBJS(.cht) $LIBS(.cht) )
        INPUT_SECTIONS( $OBJS(.rtti) $LIBS(.rtti) )
        INPUT_SECTIONS( $OBJS(.edt) $LIBS(.edt) )
	INPUT_SECTIONS( $OBJS(vtbl) $LIBS(vtbl))
        INPUT_SECTIONS( $OBJS(data4a) $LIBS(data4a) )
        INPUT_SECTIONS( $OBJS(bsz_init) $LIBS(bsz_init) )
    } >mem8_DataA

    .meminit {} > mem8_DataA

    sec_bsz ZERO_INIT
    {
        INPUT_SECTIONS( $OBJS(bsz) $LIBS(bsz) )
    } > mem8_DataA

    data4b
    {
	INPUT_SECTIONS( $OBJS_LIBS_INTERNAL(data4b))
	INPUT_SECTIONS( $OBJS_LIBS_NOT_EXTERNAL(data4b))
        INPUT_SECTIONS( $OBJS(data4b) $LIBS(data4b) )
    } >mem8_DataB

    data5a
    {
	INPUT_SECTIONS( $OBJS_LIBS_INTERNAL(data5a))
	INPUT_SECTIONS( $OBJS_LIBS_NOT_EXTERNAL(data5a))
        INPUT_SECTIONS( $OBJS(data5a) $LIBS(data5a) )
    } >mem10_DataA

    data5b
    {
	INPUT_SECTIONS( $OBJS_LIBS_INTERNAL(data5b))
	INPUT_SECTIONS( $OBJS_LIBS_NOT_EXTERNAL(data5b))
        INPUT_SECTIONS( $OBJS(data5b) $LIBS(data5b) )
    } >mem10_DataB

 // 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.

    sec_jstackseg
    {
        ldf_jstack_limit = .;
        ldf_jstack_base = . + MEMORY_SIZEOF(mem4_Stack);
    } > mem4_Stack

    sec_kstackseg
    {
        ldf_kstack_limit = .;
        ldf_kstack_base = . + MEMORY_SIZEOF(mem6_Stack);
    } > mem6_Stack

    sec_mem4_heap
    {
        ldf_defheap_base = .;
        ldf_defheap_size = MEMORY_SIZEOF(mem4_Heap);
    } > mem4_Heap

    sec_mem6_Heap
    {
        ldf_altheap_base = .;
        ldf_altheap_size = MEMORY_SIZEOF(mem6_Heap);
    } > mem6_Heap

  }
}