链接脚本（Linker Script）用法解析（一） 关键字SECTIONS与MEMORY

1.MEMORY关键字用于描述一个MCU ROM和RAM的内存地址分布（Memory Map），MEMORY中所做的内存描述主要用于SECTIONS中LMA和VMA的定义。

2.SECTIONS关键字用于定义output section（输出段）的相应input section（输入段）、LMA和VMA，是整个连接脚本中最为重要的部分。注：output section是实际存储在内存中的“段”，而input section是其构成成员，如.data为数据段，由所有全局变量构成（默认情况下）；.text为代码段，由所有函数构成（默认情况下）...

3.下面我们首先来介绍MEMORY的语法，MEMORY的语法格式如下：

MEMORY
{
　　<name> [(<attr>)] : ORIGIN = <origin>, LENGTH = <len>
　　...
}

其中<name>是所要定义的内存区域的名字，<origin>是其起始地址，<len>为内存区域的大小。另外，<attr>是可选的，并不重要，具体用法可参考GNU Linker的语法说明。

MEMORY的一个具体使用实例如下：

MEMORY
{
　　rom (rx) : ORIGIN = , LENGTH = 256K　　// MEMORY语法中可以使用如K、M和G这样的内存单位
　　ram (!rx) : org = 0x40000000, l = 4M   // ORIGIN可以写为org，而LENGTH可以写为l
}

4.在介绍SECTIONS的用法之前，我们先对之前提到的LMA和VMA进行说明：每个output section都有一个LMA和一个VMA，LMA是其存储地址，而VMA是其运行时地址，例如将全局变量g_Data所在数据段.data的LMA设为0x80000020（属于ROM地址），VMA设为0xD0004000（属于RAM地址），那么g_Data的值将存储在ROM中的0x80000020处，而程序运行时，用到g_Data的程序会到RAM中的0xD0004000处寻找它。

6.现在我们可以开始介绍SECTIONS了，SECTIONS的语法如下：

SECTIONS
{
　　<sections−command>
　　<sections−command>
　　...
}

其中主要的部分是<sections−command>，而SECTIONS{ }属于框架。<sections−command>的语法如下：

<section> [<address>] [(<type>)] : [AT(<lma>)]
{
　　<output−section−command>
　　<var{output−section−command>
　　...
} [><region>] [AT><lma region>] [:<phdr> :<phdr> ...] [=<fillexp>]

我们从使用的角度来讲解其语法：（假设有一个全局变量myData，我们用#pragma section命令将其定义为.myData段（input section））

（1）我们首先可以定义output section的名字，随便什么都可以，比如.my_data；

（2）然后我们可以定义其构成成员，*(.myData)；

（3）接下来我们就要指定.my_data的LMA和VMA了，有4种方法：

　　a) [<address>] + [AT(<lma>)]；

　　b) [<address>] + [AT><lma region>]；

　　c) [><region>] + [AT><lma region>]；

　　d) [><region>] + [AT(<lma>)].

　　但是要注意这些用法的不同：[<address>] 和 [AT(<lma>)]必须指定具体的地址，而 [><region>] 和 [AT><lma region>]只需指定内存空间，具体地址紧接着上一个output section的末尾地址。

　　经过以上步骤，我们得出如下section定义：（这里只列出2种）

SECTIONS
{
　　.my_data ( 0xD0004000 ) : AT ( 0x80000020 )
　　{
　　　　*(.myData)
　　}
　　...
}

SECTIONS
{
　　.my_data :
　　{
　　　　*(.myData)
　　} > ram AT> rom
　　...
}

　　以上为了说明SECTION的语法，使用了全局变量这种LMA和VMA不同的例子。而对于代码段.text这种LMA与VMA相同的情况，由于默认情况下LMA=VMA，因此可以只定义VMA而不必指明LMA，例如：

.text :
{
    *(.text)
    *(.text.*)
    . = ALIGN();
} > pfls0

7.最后，我们有必要提及“.”这个符号（不是.text、.data中的"."，而是如上例中.=ALIGN(4);中的"."），以下介绍来自于HighTec编译器手册

8.最后的最后，附上英飞凌TC2xx的Linker file，其中的语法和用法值得深入的去学习，可以极大地加深对链接脚本的理解。由于本篇博文着重介绍链接脚本中最重要的SECTIONS关键字的使用，大家可能在下面的链接脚本示例中碰到很多本文未提及的语法，不过这些都可以在参考手册第19章中找到。

/* Default linker script, for normal executables */
OUTPUT_FORMAT("elf32-tricore")
OUTPUT_ARCH(tricore)
ENTRY(_START)

__TRICORE_DERIVATE_MEMORY_MAP__ = 0x270;

LCF_CSA0_SIZE = 8k;
LCF_USTACK0_SIZE = 2k;
LCF_ISTACK0_SIZE = 1k;

LCF_CSA1_SIZE = 8k;
LCF_USTACK1_SIZE = 2k;
LCF_ISTACK1_SIZE = 1k;

LCF_CSA2_SIZE = 8k;
LCF_USTACK2_SIZE = 2k;
LCF_ISTACK2_SIZE = 1k;

LCF_HEAP_SIZE = 4k;

LCF_DSPR2_START = 0x50000000;
LCF_DSPR2_SIZE = 120k;

LCF_DSPR1_START = 0x60000000;
LCF_DSPR1_SIZE = 120k;

LCF_DSPR0_START = 0x70000000;
LCF_DSPR0_SIZE = 112k;

LCF_CSA2_OFFSET    =    (LCF_DSPR2_SIZE - 1k - LCF_CSA2_SIZE);
LCF_ISTACK2_OFFSET =    (LCF_CSA2_OFFSET -  - LCF_ISTACK2_SIZE);
LCF_USTACK2_OFFSET =    (LCF_ISTACK2_OFFSET -  - LCF_USTACK2_SIZE);

LCF_CSA1_OFFSET    =    (LCF_DSPR1_SIZE - 1k - LCF_CSA1_SIZE);
LCF_ISTACK1_OFFSET =    (LCF_CSA1_OFFSET -  - LCF_ISTACK1_SIZE);
LCF_USTACK1_OFFSET =    (LCF_ISTACK1_OFFSET -  - LCF_USTACK1_SIZE);

LCF_CSA0_OFFSET    =    (LCF_DSPR0_SIZE - 1k - LCF_CSA0_SIZE);
LCF_ISTACK0_OFFSET =    (LCF_CSA0_OFFSET -  - LCF_ISTACK0_SIZE);
LCF_USTACK0_OFFSET =    (LCF_ISTACK0_OFFSET -  - LCF_USTACK0_SIZE);

LCF_HEAP0_OFFSET =    (LCF_USTACK0_OFFSET - LCF_HEAP_SIZE);
LCF_HEAP1_OFFSET =    (LCF_USTACK1_OFFSET - LCF_HEAP_SIZE);
LCF_HEAP2_OFFSET =    (LCF_USTACK2_OFFSET - LCF_HEAP_SIZE);

LCF_INTVEC0_START = 0x801F4000;
LCF_TRAPVEC0_START = 0x80000100;
LCF_TRAPVEC1_START = 0x801F6800;
LCF_TRAPVEC2_START = 0x801F6000;

RESET = 0x80000020;

MEMORY
{
    dsram2_local (w!xp): org = 0xd0000000, len = 120K
    dsram2 (w!xp): org = 0x50000000, len = 120K
      psram2 (w!xp): org = 0x50100000, len = 24K

      dsram1_local (w!xp): org = 0xd0000000, len = 120K
      dsram1 (w!xp): org = 0x60000000, len = 120K
      psram1 (w!xp): org = 0x60100000, len = 24K

      dsram0_local (w!xp): org = 0xd0000000, len = 112K
      dsram0 (w!xp): org = 0x70000000, len = 112K
      psram0 (w!xp): org = 0x70100000, len = 24K

    psram_local (w!xp): org = 0xc0000000, len = 24K

    pfls0 (rx!p): org = 0x80000000, len = 2M
    pfls0_nc (rx!p): org = 0xa0000000, len = 2M

    pfls1 (rx!p): org = 0x80200000, len = 2M        /*Not used to allocate and sections*/
    pfls1_nc (rx!p): org = 0xa0200000, len = 2M     /*Not used to allocate and sections*/

    dfls0 (rx!p): org = 0xaf000000, len = 384K

    lmuram (w!xp): org = 0x90000000, len = 32K
    lmuram_nc (w!xp): org = 0xb0000000, len = 32K

    edmem (w!xp): org = 0x9f000000, len = 1M
    edmem_nc (w!xp): org = 0xbf000000, len = 1M
}    

/* map local memory address to a global address */
REGION_MAP( CPU0 , ORIGIN(dsram0_local), LENGTH(dsram0_local), ORIGIN(dsram0))
REGION_MAP( CPU1 , ORIGIN(dsram1_local), LENGTH(dsram1_local), ORIGIN(dsram1))
REGION_MAP( CPU2 , ORIGIN(dsram2_local), LENGTH(dsram2_local), ORIGIN(dsram2))

/*Un comment one of the below statements to enable CpuX DMI RAM to hold global variables*/
/*REGION_ALIAS( default_ram , dsram0)*/
REGION_ALIAS( default_ram , dsram1)
/*REGION_ALIAS( default_ram , dsram2)*/

CORE_ID = GLOBAL ;

SECTIONS
{
    /*This section is always required as Boot mode header 0 address absolutely restricted at address 0x80000000*/
    .bmhd_0 (0x80000000) : FLAGS(arl)
    {
        BootModeHeader0 = .;
        KEEP (*(.bmhd_0))
    } > pfls0

    /*This section is always required as Boot mode header 1 address absolutely restricted at address 0x80020000*/
    .bmhd_1 (0x80020000) : FLAGS(arl)
    {
        BootModeIndex = .;
        KEEP (*(.bmhd_1));
    } > pfls0

    /*This section is always required as user start address absolutely restricted at address 0x80000020*/
    .startup (0x80000020) : FLAGS(rxl)
    {
        BootModeIndex = .;
        . = ALIGN();
        KEEP (*(.start));
        . = ALIGN();
    } > pfls0 =0x800

     /*This section contains the data indirection pointers to interface external devices*/
    .interface_const (0x80000040) :
    {
        __IF_CONST = .;
        KEEP (*(.interface_const));
        . = ALIGN();
    } > pfls0

    .traptab_tc0 (LCF_TRAPVEC0_START) :
    {
        PROVIDE(__TRAPTAB_CPU0 = .);
        KEEP (*(.traptab_cpu0));
    } > pfls0

    .zrodata : FLAGS(arl)
    {
        *(.zrodata)
        *(.zrodata.*)
    } > pfls0

    .sdata2 : FLAGS(arsl)
    {
        *(.srodata)
        *(.srodata.*)
    } > pfls0

    _SMALL_DATA2_ = SIZEOF(CORE_SEC(.sdata2)) ? ADDR(CORE_SEC(.sdata2)) + 32k : (ADDR(CORE_SEC(.sdata2)) & 0xF0000000) + 32k ;
    __A1_MEM = _SMALL_DATA2_;

       .rodata : FLAGS(arl)
    {
        *(.rodata)
        *(.rodata.*)
        *(.gnu.linkonce.r.*)
        /*
          * Create the clear and copy tables that tell the startup code
          * which memory areas to clear and to copy, respectively.
          */
        . = ALIGN() ;
        PROVIDE(__clear_table = .) ;
        LONG( + ADDR(.CPU2.zbss));     LONG(SIZEOF(.CPU2.zbss));
        LONG( + ADDR(.CPU2.bss));    LONG(SIZEOF(.CPU2.bss));
        LONG( + ADDR(.CPU1.zbss));     LONG(SIZEOF(.CPU1.zbss));
        LONG( + ADDR(.CPU1.bss));    LONG(SIZEOF(.CPU1.bss));
        LONG( + ADDR(.CPU0.zbss));     LONG(SIZEOF(.CPU0.zbss));
        LONG( + ADDR(.CPU0.bss));    LONG(SIZEOF(.CPU0.bss));
        LONG( + ADDR(.zbss));     LONG(SIZEOF(.zbss));
        LONG( + ADDR(.sbss));     LONG(SIZEOF(.sbss));
        LONG( + ADDR(.bss));    LONG(SIZEOF(.bss));
        LONG( + ADDR(.sbss4));    LONG(SIZEOF(.sbss4));
        LONG( + ADDR(.bss_emem));    LONG(SIZEOF(.bss_emem));
        LONG(-);                 LONG(-);
        PROVIDE(__copy_table = .) ;
        LONG(LOADADDR(.CPU2.zdata));    LONG( + ADDR(.CPU2.zdata));    LONG(SIZEOF(.CPU2.zdata));
        LONG(LOADADDR(.CPU2.data));    LONG( + ADDR(.CPU2.data));    LONG(SIZEOF(.CPU2.data));
        LONG(LOADADDR(.CPU1.zdata));    LONG( + ADDR(.CPU1.zdata));    LONG(SIZEOF(.CPU1.zdata));
        LONG(LOADADDR(.CPU1.data));    LONG( + ADDR(.CPU1.data));    LONG(SIZEOF(.CPU1.data));
        LONG(LOADADDR(.CPU0.zdata));    LONG( + ADDR(.CPU0.zdata));    LONG(SIZEOF(.CPU0.zdata));
        LONG(LOADADDR(.CPU0.data));    LONG( + ADDR(.CPU0.data));    LONG(SIZEOF(.CPU0.data));
        LONG(LOADADDR(.zdata));    LONG( + ADDR(.zdata));    LONG(SIZEOF(.zdata));
        LONG(LOADADDR(.sdata));    LONG( + ADDR(.sdata));    LONG(SIZEOF(.sdata));
        LONG(LOADADDR(.data));    LONG( + ADDR(.data));    LONG(SIZEOF(.data));
        LONG(LOADADDR(.data_emem));    LONG( + ADDR(.data_emem));    LONG(SIZEOF(.data_emem));
        LONG(LOADADDR(.data_lmu));    LONG( + ADDR(.data_lmu));    LONG(SIZEOF(.data_lmu));
        LONG(LOADADDR(.sdata4));    LONG( + ADDR(.sdata4));    LONG(SIZEOF(.sdata4));
        LONG(LOADADDR(.CPU0.psram_text));    LONG( + ADDR(.CPU0.psram_text));    LONG(SIZEOF(.CPU0.psram_text));
        LONG(LOADADDR(.CPU1.psram_text));    LONG( + ADDR(.CPU1.psram_text));    LONG(SIZEOF(.CPU1.psram_text));
        LONG(LOADADDR(.CPU2.psram_text));    LONG( + ADDR(.CPU2.psram_text));    LONG(SIZEOF(.CPU2.psram_text));
        LONG(-);                 LONG(-);                 LONG(-);
        . = ALIGN();
      } > pfls0

      .text  : FLAGS(axl)
    {
        *(.text)
        *(.text.*)
        *(.gnu.linkonce.t.*)
        *(.gnu.warning)        /* .gnu.warning sections are handled specially by elf32.em. */
        . = ALIGN();
    } > pfls0

    /*
     * C++ exception handling tables.  NOTE: gcc emits .eh_frame
     * sections when compiling C sources with debugging enabled (-g).
     * If you can be sure that your final application consists
     * exclusively of C objects (i.e., no C++ objects), you may use
     * the -R option of the "strip" and "objcopy" utilities to remove
     * the .eh_frame section from the executable.
     */
    .eh_frame  :
    {
        *(.gcc_except_table)
        __EH_FRAME_BEGIN__ = . ;
        KEEP (*(.eh_frame))
        __EH_FRAME_END__ = . ;
        . = ALIGN();
    } > pfls0

    /*
     * Constructors and destructors.
     */
    .ctors : FLAGS(ar)
    {
        __CTOR_LIST__ = . ;
        LONG((__CTOR_END__ - __CTOR_LIST__) /  - );
        *(.ctors)
        LONG() ;
        __CTOR_END__ = . ;
        . = ALIGN();
    } > pfls0
    .dtors : FLAGS(ar)
    {
        __DTOR_LIST__ = . ;
        LONG((__DTOR_END__ - __DTOR_LIST__) /  - );
        *(.dtors)
        LONG() ;
        __DTOR_END__ = . ;
        . = ALIGN();
    } > pfls0

    .traptab_tc2 (LCF_TRAPVEC2_START) :
    {
        PROVIDE(__TRAPTAB_CPU2 = .);
        KEEP (*(.traptab_cpu2));
    } > pfls0

    .traptab_tc1 (LCF_TRAPVEC1_START) :
    {
        PROVIDE(__TRAPTAB_CPU1 = .);
        KEEP (*(.traptab_cpu1));
    } > pfls0
}

/*Near data sections*/

CORE_ID = CPU2 ;

SECTIONS
{
    CORE_SEC(.zdata) (LCF_DSPR2_START): FLAGS(awzl)
    {
        . = ALIGN() ;
        *(.zdata_cpu2)
        *(.zdata_cpu2.*)
    } > dsram2 AT> pfls0

    CORE_SEC(.zbss) (NOLOAD): FLAGS(awz)
    {
        . = ALIGN() ;
        *(.zbss_cpu2)
        *(.zbss_cpu2.*)
    } > dsram2

}

CORE_ID = CPU1;

SECTIONS
{
    CORE_SEC(.zdata) (LCF_DSPR1_START): FLAGS(awzl)
    {
        . = ALIGN() ;
        *(.zdata_cpu1)
        *(.zdata_cpu1.*)
    } > dsram1 AT> pfls0

    CORE_SEC(.zbss): FLAGS(awz)
    {
        . = ALIGN() ;
        *(.zbss_cpu1)
        *(.zbss_cpu1.*)
    } > dsram1
}

CORE_ID = CPU0;

SECTIONS
{
    CORE_SEC(.zdata) (LCF_DSPR0_START): FLAGS(awzl)
    {
        . = ALIGN() ;
        *(.zdata_cpu0)
        *(.zdata_cpu0.*)
    } > dsram0 AT> pfls0

    CORE_SEC(.zbss) (NOLOAD): FLAGS(awz)
    {
        . = ALIGN() ;
        *(.zbss_cpu0)
        *(.zbss_cpu0.*)
    } > dsram0
}

/*RAM sections without cpu sufix will go to default ram defined above with REGION_ALIAS*/

CORE_ID = GLOBAL;

SECTIONS
{
    CORE_SEC(.zdata) : FLAGS(awzl)
    {
        . = ALIGN() ;
        *(.zdata)
        *(.zdata.*)
        *(.gnu.linkonce.z.*)
    } > default_ram AT> pfls0

    CORE_SEC(.zbss) (NOLOAD) : FLAGS(awz)
    {
        . = ALIGN() ;
        *(.zbss)
        *(.zbss.*)
        *(.bbss)
        *(.bbss.*)
        *(.gnu.linkonce.zb.*)
    } > default_ram

    CORE_SEC(.sdata) : FLAGS(awsl)
    {
        . = ALIGN() ;
        *(.sdata)
        *(.sdata.*)
    } > default_ram AT> pfls0
    _SMALL_DATA_ = SIZEOF(CORE_SEC(.sdata)) ? ADDR(CORE_SEC(.sdata)) + 32k : (ADDR(CORE_SEC(.sdata)) & 0xF0000000) + 32k ;
    __A0_MEM = _SMALL_DATA_;

    CORE_SEC(.sbss) (NOLOAD): FLAGS(aws)
    {
        . = ALIGN() ;
        *(.sbss)
        *(.sbss.*)
    } > default_ram

    CORE_SEC(.data) : FLAGS(awl)
    {
        . = ALIGN() ;
        *(.data)
        *(.data.*)
        *(.gnu.linkonce.d.*)
    } > default_ram AT> pfls0

    CORE_SEC(.bss) (NOLOAD) : FLAGS(aw)
    {
        . = ALIGN() ;
        *(.bss)
        *(.bss.*)
        *(.gnu.linkonce.b.*)
    } > default_ram

    .heap  : FLAGS(aw)
    {
        . = ALIGN();
        __HEAP = .;
        . += LCF_HEAP_SIZE;
        __HEAP_END = .;
    } > default_ram
}

CORE_ID = CPU2 ;

SECTIONS
{
    CORE_SEC(.data) : FLAGS(awl)
    {
        . = ALIGN() ;
        *(.data_cpu2)
        *(.data_cpu2.*)
    } > dsram2 AT> pfls0

    CORE_SEC(.bss) (NOLOAD): FLAGS(aw)
    {
        . = ALIGN() ;
        *(.bss_cpu2)
        *(.bss_cpu2.*)
    } > dsram2
}

CORE_ID = CPU1;

SECTIONS
{
    CORE_SEC(.data) : FLAGS(awl)
    {
        . = ALIGN() ;
        *(.data_cpu1)
        *(.data_cpu1.*)
    } > dsram1 AT> pfls0

    CORE_SEC(.bss) (NOLOAD): FLAGS(aw)
    {
        . = ALIGN() ;
        *(.bss_cpu1)
        *(.bss_cpu1.*)
    } > dsram1
}

CORE_ID = CPU0;

SECTIONS
{
    CORE_SEC(.data) : FLAGS(awl)
    {
        . = ALIGN() ;
        *(.data_cpu0)
        *(.data_cpu0.*)
    } > dsram0 AT> pfls0

    CORE_SEC(.bss) (NOLOAD): FLAGS(aw)
    {
        . = ALIGN() ;
        *(.bss_cpu0)
        *(.bss_cpu0.*)
    } > dsram0

    CORE_SEC(.psram_text)  : FLAGS(awx)
    {
        . = ALIGN();
        *(.cpu0_psram)
    } > psram0 AT> pfls0
}

CORE_ID = CPU2 ;

SECTIONS
{
    CORE_SEC(.ustack) (LCF_DSPR2_START + LCF_USTACK2_OFFSET):
    {
        PROVIDE(__USTACK2_END = .);
        . = . + LCF_USTACK2_SIZE;
        PROVIDE(__USTACK2 = .);
    } > dsram2

    CORE_SEC(.istack) (LCF_DSPR2_START + LCF_ISTACK2_OFFSET):
    {
        PROVIDE(__ISTACK2_END = .);
        . = . + LCF_ISTACK2_SIZE;
        PROVIDE(__ISTACK2 = .);
    } > dsram2

    CORE_SEC(.csa) (LCF_DSPR2_START + LCF_CSA2_OFFSET):
    {
        PROVIDE(__CSA2 = .);
        . = . + LCF_CSA2_SIZE;
        PROVIDE(__CSA2_END = .);
    } > dsram2

    CORE_SEC(.psram_text)  : FLAGS(awx)
    {
        . = ALIGN();
        *(.cpu2_psram)
    } > psram2 AT> pfls0
}

CORE_ID = CPU1;

SECTIONS
{
    CORE_SEC(.ustack) (LCF_DSPR1_START + LCF_USTACK1_OFFSET):
    {
        PROVIDE(__USTACK1_END = .);
        . = . + LCF_USTACK1_SIZE;
        PROVIDE(__USTACK1 = .);
    } > dsram1

    CORE_SEC(.istack) (LCF_DSPR1_START + LCF_ISTACK1_OFFSET):
    {
        PROVIDE(__ISTACK1_END = .);
        . = . + LCF_ISTACK1_SIZE;
        PROVIDE(__ISTACK1 = .);
    } > dsram1

    CORE_SEC(.csa) (LCF_DSPR1_START + LCF_CSA1_OFFSET):
    {
        PROVIDE(__CSA1 = .);
        . = . + LCF_CSA1_SIZE;
        PROVIDE(__CSA1_END = .);
    } > dsram1

    CORE_SEC(.psram_text)  : FLAGS(awx)
    {
        . = ALIGN();
        *(.cpu1_psram)
    } > psram1 AT> pfls0
}

CORE_ID = CPU0;

SECTIONS
{
    CORE_SEC(.ustack) (LCF_DSPR0_START + LCF_USTACK0_OFFSET):
    {
        PROVIDE(__USTACK0_END = .);
        . = . + LCF_USTACK0_SIZE;
        PROVIDE(__USTACK0 = .);
    } > dsram0

    CORE_SEC(.istack) (LCF_DSPR0_START + LCF_ISTACK0_OFFSET):
    {
        PROVIDE(__ISTACK0_END = .);
        . = . + LCF_ISTACK0_SIZE;
        PROVIDE(__ISTACK0 = .);
    } > dsram0

    CORE_SEC(.csa) (LCF_DSPR0_START + LCF_CSA0_OFFSET):
    {
        PROVIDE(__CSA0 = .);
        . = . + LCF_CSA0_SIZE;
        PROVIDE(__CSA0_END = .);
    } > dsram0
}    

CORE_ID = GLOBAL;

SECTIONS
{
       CORE_SEC(.sdata3) : FLAGS(arsl)
    {
        *(.rodata_a8)
            *(.rodata_a8.*)
    } > pfls0

    _SMALL_DATA3_ = SIZEOF(CORE_SEC(.sdata3)) ? ADDR(CORE_SEC(.sdata3)) + 32k : (ADDR(CORE_SEC(.sdata3)) & 0xF0000000) + 32k ;
    __A8_MEM = _SMALL_DATA3_;

    .data_lmu : FLAGS(awl)
    {
        *(.lmudata)
            *(.lmudata.*)
    } > lmuram AT> pfls0

    .bss_lmu (NOLOAD): FLAGS(aw)
    {
        *(.lmubss)
            *(.lmubss.*)
    } > lmuram

    .sdata4 : FLAGS(awsl)
    {
        *(.sdata_a9)
        *(.sdata_a9.*)
        *(.lmu_data)
            *(.lmu_data.*)
    } > lmuram AT> pfls0

    .sbss4 (NOLOAD): FLAGS(aws)
    {
        *(.sbss_a9)
        *(.sbss_a9.*)
        *(.lmu_bss)
            *(.lmu_bss.*)
    } > lmuram

    _SMALL_DATA4_ = SIZEOF(.sdata4) ? ADDR(.sdata4) + 32k : (ADDR(.sdata4) & 0xF0000000) + 32k ;
    __A9_MEM = _SMALL_DATA4_;

    .data_emem : FLAGS(awl)
    {
        . = ALIGN() ;
        *(.data_emem)
        *(.data_emem.*)
        *(.gnu.linkonce.d.*)
    } > edmem_nc AT> pfls0

    .bss_emem (NOLOAD) : FLAGS(aw)
    {
        . = ALIGN() ;
        *(.bss_emem)
        *(.bss_emem.*)
        *(.gnu.linkonce.b.*)
    } > edmem_nc

    .inttab_tc0_000 (LCF_INTVEC0_START + 0x0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_0)); } > pfls0
    .inttab_tc0_001 (LCF_INTVEC0_START + 0x20) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_1)); } > pfls0
    .inttab_tc0_002 (LCF_INTVEC0_START + 0x40) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_2)); } > pfls0
    .inttab_tc0_003 (LCF_INTVEC0_START + 0x60) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_3)); } > pfls0
    .inttab_tc0_004 (LCF_INTVEC0_START + 0x80) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_4)); } > pfls0
    .inttab_tc0_005 (LCF_INTVEC0_START + 0xA0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_5)); } > pfls0
    .inttab_tc0_006 (LCF_INTVEC0_START + 0xC0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_6)); } > pfls0
    .inttab_tc0_007 (LCF_INTVEC0_START + 0xE0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_7)); } > pfls0
    .inttab_tc0_008 (LCF_INTVEC0_START + 0x100) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_8)); } > pfls0
    .inttab_tc0_009 (LCF_INTVEC0_START + 0x120) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_9)); } > pfls0
    .inttab_tc0_00A (LCF_INTVEC0_START + 0x140) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_10)); } > pfls0
    .inttab_tc0_00B (LCF_INTVEC0_START + 0x160) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_11)); } > pfls0
    .inttab_tc0_00C (LCF_INTVEC0_START + 0x180) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_12)); } > pfls0
    .inttab_tc0_00D (LCF_INTVEC0_START + 0x1A0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_13)); } > pfls0
    .inttab_tc0_00E (LCF_INTVEC0_START + 0x1C0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_14)); } > pfls0
    .inttab_tc0_00F (LCF_INTVEC0_START + 0x1E0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_15)); } > pfls0
    .inttab_tc0_010 (LCF_INTVEC0_START + 0x200) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_16)); } > pfls0
    .inttab_tc0_011 (LCF_INTVEC0_START + 0x220) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_17)); } > pfls0
    .inttab_tc0_012 (LCF_INTVEC0_START + 0x240) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_18)); } > pfls0
    .inttab_tc0_013 (LCF_INTVEC0_START + 0x260) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_19)); } > pfls0
    .inttab_tc0_014 (LCF_INTVEC0_START + 0x280) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_20)); } > pfls0
    .inttab_tc0_015 (LCF_INTVEC0_START + 0x2A0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_21)); } > pfls0
    .inttab_tc0_016 (LCF_INTVEC0_START + 0x2C0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_22)); } > pfls0
    .inttab_tc0_017 (LCF_INTVEC0_START + 0x2E0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_23)); } > pfls0
    .inttab_tc0_018 (LCF_INTVEC0_START + 0x300) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_24)); } > pfls0
    .inttab_tc0_019 (LCF_INTVEC0_START + 0x320) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_25)); } > pfls0
    .inttab_tc0_01A (LCF_INTVEC0_START + 0x340) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_26)); } > pfls0
    .inttab_tc0_01B (LCF_INTVEC0_START + 0x360) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_27)); } > pfls0
    .inttab_tc0_01C (LCF_INTVEC0_START + 0x380) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_28)); } > pfls0
    .inttab_tc0_01D (LCF_INTVEC0_START + 0x3A0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_29)); } > pfls0
    .inttab_tc0_01E (LCF_INTVEC0_START + 0x3C0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_30)); } > pfls0
    .inttab_tc0_01F (LCF_INTVEC0_START + 0x3E0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_31)); } > pfls0
    .inttab_tc0_020 (LCF_INTVEC0_START + 0x400) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_32)); } > pfls0
    .inttab_tc0_021 (LCF_INTVEC0_START + 0x420) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_33)); } > pfls0
    .inttab_tc0_022 (LCF_INTVEC0_START + 0x440) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_34)); } > pfls0
    .inttab_tc0_023 (LCF_INTVEC0_START + 0x460) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_35)); } > pfls0
    .inttab_tc0_024 (LCF_INTVEC0_START + 0x480) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_36)); } > pfls0
    .inttab_tc0_025 (LCF_INTVEC0_START + 0x4A0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_37)); } > pfls0
    .inttab_tc0_026 (LCF_INTVEC0_START + 0x4C0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_38)); } > pfls0
    .inttab_tc0_027 (LCF_INTVEC0_START + 0x4E0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_39)); } > pfls0
    .inttab_tc0_028 (LCF_INTVEC0_START + 0x500) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_40)); } > pfls0
    .inttab_tc0_029 (LCF_INTVEC0_START + 0x520) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_41)); } > pfls0
    .inttab_tc0_02A (LCF_INTVEC0_START + 0x540) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_42)); } > pfls0
    .inttab_tc0_02B (LCF_INTVEC0_START + 0x560) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_43)); } > pfls0
    .inttab_tc0_02C (LCF_INTVEC0_START + 0x580) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_44)); } > pfls0
    .inttab_tc0_02D (LCF_INTVEC0_START + 0x5A0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_45)); } > pfls0
    .inttab_tc0_02E (LCF_INTVEC0_START + 0x5C0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_46)); } > pfls0
    .inttab_tc0_02F (LCF_INTVEC0_START + 0x5E0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_47)); } > pfls0
    .inttab_tc0_030 (LCF_INTVEC0_START + 0x600) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_48)); } > pfls0
    .inttab_tc0_031 (LCF_INTVEC0_START + 0x620) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_49)); } > pfls0
    .inttab_tc0_032 (LCF_INTVEC0_START + 0x640) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_50)); } > pfls0
    .inttab_tc0_033 (LCF_INTVEC0_START + 0x660) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_51)); } > pfls0
    .inttab_tc0_034 (LCF_INTVEC0_START + 0x680) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_52)); } > pfls0
    .inttab_tc0_035 (LCF_INTVEC0_START + 0x6A0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_53)); } > pfls0
    .inttab_tc0_036 (LCF_INTVEC0_START + 0x6C0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_54)); } > pfls0
    .inttab_tc0_037 (LCF_INTVEC0_START + 0x6E0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_55)); } > pfls0
    .inttab_tc0_038 (LCF_INTVEC0_START + 0x700) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_56)); } > pfls0
    .inttab_tc0_039 (LCF_INTVEC0_START + 0x720) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_57)); } > pfls0
    .inttab_tc0_03A (LCF_INTVEC0_START + 0x740) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_58)); } > pfls0
    .inttab_tc0_03B (LCF_INTVEC0_START + 0x760) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_59)); } > pfls0
    .inttab_tc0_03C (LCF_INTVEC0_START + 0x780) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_60)); } > pfls0
    .inttab_tc0_03D (LCF_INTVEC0_START + 0x7A0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_61)); } > pfls0
    .inttab_tc0_03E (LCF_INTVEC0_START + 0x7C0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_62)); } > pfls0
    .inttab_tc0_03F (LCF_INTVEC0_START + 0x7E0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_63)); } > pfls0
    .inttab_tc0_040 (LCF_INTVEC0_START + 0x800) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_64)); } > pfls0
    .inttab_tc0_041 (LCF_INTVEC0_START + 0x820) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_65)); } > pfls0
    .inttab_tc0_042 (LCF_INTVEC0_START + 0x840) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_66)); } > pfls0
    .inttab_tc0_043 (LCF_INTVEC0_START + 0x860) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_67)); } > pfls0
    .inttab_tc0_044 (LCF_INTVEC0_START + 0x880) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_68)); } > pfls0
    .inttab_tc0_045 (LCF_INTVEC0_START + 0x8A0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_69)); } > pfls0
    .inttab_tc0_046 (LCF_INTVEC0_START + 0x8C0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_70)); } > pfls0
    .inttab_tc0_047 (LCF_INTVEC0_START + 0x8E0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_71)); } > pfls0
    .inttab_tc0_048 (LCF_INTVEC0_START + 0x900) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_72)); } > pfls0
    .inttab_tc0_049 (LCF_INTVEC0_START + 0x920) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_73)); } > pfls0
    .inttab_tc0_04A (LCF_INTVEC0_START + 0x940) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_74)); } > pfls0
    .inttab_tc0_04B (LCF_INTVEC0_START + 0x960) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_75)); } > pfls0
    .inttab_tc0_04C (LCF_INTVEC0_START + 0x980) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_76)); } > pfls0
    .inttab_tc0_04D (LCF_INTVEC0_START + 0x9A0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_77)); } > pfls0
    .inttab_tc0_04E (LCF_INTVEC0_START + 0x9C0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_78)); } > pfls0
    .inttab_tc0_04F (LCF_INTVEC0_START + 0x9E0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_79)); } > pfls0
    .inttab_tc0_050 (LCF_INTVEC0_START + 0xA00) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_80)); } > pfls0
    .inttab_tc0_051 (LCF_INTVEC0_START + 0xA20) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_81)); } > pfls0
    .inttab_tc0_052 (LCF_INTVEC0_START + 0xA40) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_82)); } > pfls0
    .inttab_tc0_053 (LCF_INTVEC0_START + 0xA60) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_83)); } > pfls0
    .inttab_tc0_054 (LCF_INTVEC0_START + 0xA80) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_84)); } > pfls0
    .inttab_tc0_055 (LCF_INTVEC0_START + 0xAA0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_85)); } > pfls0
    .inttab_tc0_056 (LCF_INTVEC0_START + 0xAC0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_86)); } > pfls0
    .inttab_tc0_057 (LCF_INTVEC0_START + 0xAE0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_87)); } > pfls0
    .inttab_tc0_058 (LCF_INTVEC0_START + 0xB00) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_88)); } > pfls0
    .inttab_tc0_059 (LCF_INTVEC0_START + 0xB20) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_89)); } > pfls0
    .inttab_tc0_05A (LCF_INTVEC0_START + 0xB40) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_90)); } > pfls0
    .inttab_tc0_05B (LCF_INTVEC0_START + 0xB60) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_91)); } > pfls0
    .inttab_tc0_05C (LCF_INTVEC0_START + 0xB80) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_92)); } > pfls0
    .inttab_tc0_05D (LCF_INTVEC0_START + 0xBA0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_93)); } > pfls0
    .inttab_tc0_05E (LCF_INTVEC0_START + 0xBC0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_94)); } > pfls0
    .inttab_tc0_05F (LCF_INTVEC0_START + 0xBE0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_95)); } > pfls0
    .inttab_tc0_060 (LCF_INTVEC0_START + 0xC00) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_96)); } > pfls0
    .inttab_tc0_061 (LCF_INTVEC0_START + 0xC20) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_97)); } > pfls0
    .inttab_tc0_062 (LCF_INTVEC0_START + 0xC40) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_98)); } > pfls0
    .inttab_tc0_063 (LCF_INTVEC0_START + 0xC60) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_99)); } > pfls0
    .inttab_tc0_064 (LCF_INTVEC0_START + 0xC80) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_100)); } > pfls0
    .inttab_tc0_065 (LCF_INTVEC0_START + 0xCA0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_101)); } > pfls0
    .inttab_tc0_066 (LCF_INTVEC0_START + 0xCC0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_102)); } > pfls0
    .inttab_tc0_067 (LCF_INTVEC0_START + 0xCE0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_103)); } > pfls0
    .inttab_tc0_068 (LCF_INTVEC0_START + 0xD00) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_104)); } > pfls0
    .inttab_tc0_069 (LCF_INTVEC0_START + 0xD20) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_105)); } > pfls0
    .inttab_tc0_06A (LCF_INTVEC0_START + 0xD40) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_106)); } > pfls0
    .inttab_tc0_06B (LCF_INTVEC0_START + 0xD60) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_107)); } > pfls0
    .inttab_tc0_06C (LCF_INTVEC0_START + 0xD80) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_108)); } > pfls0
    .inttab_tc0_06D (LCF_INTVEC0_START + 0xDA0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_109)); } > pfls0
    .inttab_tc0_06E (LCF_INTVEC0_START + 0xDC0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_110)); } > pfls0
    .inttab_tc0_06F (LCF_INTVEC0_START + 0xDE0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_111)); } > pfls0
    .inttab_tc0_070 (LCF_INTVEC0_START + 0xE00) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_112)); } > pfls0
    .inttab_tc0_071 (LCF_INTVEC0_START + 0xE20) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_113)); } > pfls0
    .inttab_tc0_072 (LCF_INTVEC0_START + 0xE40) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_114)); } > pfls0
    .inttab_tc0_073 (LCF_INTVEC0_START + 0xE60) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_115)); } > pfls0
    .inttab_tc0_074 (LCF_INTVEC0_START + 0xE80) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_116)); } > pfls0
    .inttab_tc0_075 (LCF_INTVEC0_START + 0xEA0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_117)); } > pfls0
    .inttab_tc0_076 (LCF_INTVEC0_START + 0xEC0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_118)); } > pfls0
    .inttab_tc0_077 (LCF_INTVEC0_START + 0xEE0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_119)); } > pfls0
    .inttab_tc0_078 (LCF_INTVEC0_START + 0xF00) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_120)); } > pfls0
    .inttab_tc0_079 (LCF_INTVEC0_START + 0xF20) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_121)); } > pfls0
    .inttab_tc0_07A (LCF_INTVEC0_START + 0xF40) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_122)); } > pfls0
    .inttab_tc0_07B (LCF_INTVEC0_START + 0xF60) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_123)); } > pfls0
    .inttab_tc0_07C (LCF_INTVEC0_START + 0xF80) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_124)); } > pfls0
    .inttab_tc0_07D (LCF_INTVEC0_START + 0xFA0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_125)); } > pfls0
    .inttab_tc0_07E (LCF_INTVEC0_START + 0xFC0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_126)); } > pfls0
    .inttab_tc0_07F (LCF_INTVEC0_START + 0xFE0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_127)); } > pfls0
    .inttab_tc0_080 (LCF_INTVEC0_START + 0x1000) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_128)); } > pfls0
    .inttab_tc0_081 (LCF_INTVEC0_START + 0x1020) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_129)); } > pfls0
    .inttab_tc0_082 (LCF_INTVEC0_START + 0x1040) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_130)); } > pfls0
    .inttab_tc0_083 (LCF_INTVEC0_START + 0x1060) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_131)); } > pfls0
    .inttab_tc0_084 (LCF_INTVEC0_START + 0x1080) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_132)); } > pfls0
    .inttab_tc0_085 (LCF_INTVEC0_START + 0x10A0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_133)); } > pfls0
    .inttab_tc0_086 (LCF_INTVEC0_START + 0x10C0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_134)); } > pfls0
    .inttab_tc0_087 (LCF_INTVEC0_START + 0x10E0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_135)); } > pfls0
    .inttab_tc0_088 (LCF_INTVEC0_START + 0x1100) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_136)); } > pfls0
    .inttab_tc0_089 (LCF_INTVEC0_START + 0x1120) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_137)); } > pfls0
    .inttab_tc0_08A (LCF_INTVEC0_START + 0x1140) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_138)); } > pfls0
    .inttab_tc0_08B (LCF_INTVEC0_START + 0x1160) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_139)); } > pfls0
    .inttab_tc0_08C (LCF_INTVEC0_START + 0x1180) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_140)); } > pfls0
    .inttab_tc0_08D (LCF_INTVEC0_START + 0x11A0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_141)); } > pfls0
    .inttab_tc0_08E (LCF_INTVEC0_START + 0x11C0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_142)); } > pfls0
    .inttab_tc0_08F (LCF_INTVEC0_START + 0x11E0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_143)); } > pfls0
    .inttab_tc0_090 (LCF_INTVEC0_START + 0x1200) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_144)); } > pfls0
    .inttab_tc0_091 (LCF_INTVEC0_START + 0x1220) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_145)); } > pfls0
    .inttab_tc0_092 (LCF_INTVEC0_START + 0x1240) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_146)); } > pfls0
    .inttab_tc0_093 (LCF_INTVEC0_START + 0x1260) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_147)); } > pfls0
    .inttab_tc0_094 (LCF_INTVEC0_START + 0x1280) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_148)); } > pfls0
    .inttab_tc0_095 (LCF_INTVEC0_START + 0x12A0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_149)); } > pfls0
    .inttab_tc0_096 (LCF_INTVEC0_START + 0x12C0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_150)); } > pfls0
    .inttab_tc0_097 (LCF_INTVEC0_START + 0x12E0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_151)); } > pfls0
    .inttab_tc0_098 (LCF_INTVEC0_START + 0x1300) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_152)); } > pfls0
    .inttab_tc0_099 (LCF_INTVEC0_START + 0x1320) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_153)); } > pfls0
    .inttab_tc0_09A (LCF_INTVEC0_START + 0x1340) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_154)); } > pfls0
    .inttab_tc0_09B (LCF_INTVEC0_START + 0x1360) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_155)); } > pfls0
    .inttab_tc0_09C (LCF_INTVEC0_START + 0x1380) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_156)); } > pfls0
    .inttab_tc0_09D (LCF_INTVEC0_START + 0x13A0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_157)); } > pfls0
    .inttab_tc0_09E (LCF_INTVEC0_START + 0x13C0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_158)); } > pfls0
    .inttab_tc0_09F (LCF_INTVEC0_START + 0x13E0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_159)); } > pfls0
    .inttab_tc0_0A0 (LCF_INTVEC0_START + 0x1400) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_160)); } > pfls0
    .inttab_tc0_0A1 (LCF_INTVEC0_START + 0x1420) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_161)); } > pfls0
    .inttab_tc0_0A2 (LCF_INTVEC0_START + 0x1440) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_162)); } > pfls0
    .inttab_tc0_0A3 (LCF_INTVEC0_START + 0x1460) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_163)); } > pfls0
    .inttab_tc0_0A4 (LCF_INTVEC0_START + 0x1480) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_164)); } > pfls0
    .inttab_tc0_0A5 (LCF_INTVEC0_START + 0x14A0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_165)); } > pfls0
    .inttab_tc0_0A6 (LCF_INTVEC0_START + 0x14C0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_166)); } > pfls0
    .inttab_tc0_0A7 (LCF_INTVEC0_START + 0x14E0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_167)); } > pfls0
    .inttab_tc0_0A8 (LCF_INTVEC0_START + 0x1500) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_168)); } > pfls0
    .inttab_tc0_0A9 (LCF_INTVEC0_START + 0x1520) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_169)); } > pfls0
    .inttab_tc0_0AA (LCF_INTVEC0_START + 0x1540) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_170)); } > pfls0
    .inttab_tc0_0AB (LCF_INTVEC0_START + 0x1560) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_171)); } > pfls0
    .inttab_tc0_0AC (LCF_INTVEC0_START + 0x1580) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_172)); } > pfls0
    .inttab_tc0_0AD (LCF_INTVEC0_START + 0x15A0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_173)); } > pfls0
    .inttab_tc0_0AE (LCF_INTVEC0_START + 0x15C0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_174)); } > pfls0
    .inttab_tc0_0AF (LCF_INTVEC0_START + 0x15E0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_175)); } > pfls0
    .inttab_tc0_0B0 (LCF_INTVEC0_START + 0x1600) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_176)); } > pfls0
    .inttab_tc0_0B1 (LCF_INTVEC0_START + 0x1620) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_177)); } > pfls0
    .inttab_tc0_0B2 (LCF_INTVEC0_START + 0x1640) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_178)); } > pfls0
    .inttab_tc0_0B3 (LCF_INTVEC0_START + 0x1660) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_179)); } > pfls0
    .inttab_tc0_0B4 (LCF_INTVEC0_START + 0x1680) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_180)); } > pfls0
    .inttab_tc0_0B5 (LCF_INTVEC0_START + 0x16A0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_181)); } > pfls0
    .inttab_tc0_0B6 (LCF_INTVEC0_START + 0x16C0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_182)); } > pfls0
    .inttab_tc0_0B7 (LCF_INTVEC0_START + 0x16E0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_183)); } > pfls0
    .inttab_tc0_0B8 (LCF_INTVEC0_START + 0x1700) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_184)); } > pfls0
    .inttab_tc0_0B9 (LCF_INTVEC0_START + 0x1720) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_185)); } > pfls0
    .inttab_tc0_0BA (LCF_INTVEC0_START + 0x1740) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_186)); } > pfls0
    .inttab_tc0_0BB (LCF_INTVEC0_START + 0x1760) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_187)); } > pfls0
    .inttab_tc0_0BC (LCF_INTVEC0_START + 0x1780) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_188)); } > pfls0
    .inttab_tc0_0BD (LCF_INTVEC0_START + 0x17A0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_189)); } > pfls0
    .inttab_tc0_0BE (LCF_INTVEC0_START + 0x17C0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_190)); } > pfls0
    .inttab_tc0_0BF (LCF_INTVEC0_START + 0x17E0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_191)); } > pfls0
    .inttab_tc0_0C0 (LCF_INTVEC0_START + 0x1800) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_192)); } > pfls0
    .inttab_tc0_0C1 (LCF_INTVEC0_START + 0x1820) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_193)); } > pfls0
    .inttab_tc0_0C2 (LCF_INTVEC0_START + 0x1840) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_194)); } > pfls0
    .inttab_tc0_0C3 (LCF_INTVEC0_START + 0x1860) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_195)); } > pfls0
    .inttab_tc0_0C4 (LCF_INTVEC0_START + 0x1880) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_196)); } > pfls0
    .inttab_tc0_0C5 (LCF_INTVEC0_START + 0x18A0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_197)); } > pfls0
    .inttab_tc0_0C6 (LCF_INTVEC0_START + 0x18C0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_198)); } > pfls0
    .inttab_tc0_0C7 (LCF_INTVEC0_START + 0x18E0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_199)); } > pfls0
    .inttab_tc0_0C8 (LCF_INTVEC0_START + 0x1900) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_200)); } > pfls0
    .inttab_tc0_0C9 (LCF_INTVEC0_START + 0x1920) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_201)); } > pfls0
    .inttab_tc0_0CA (LCF_INTVEC0_START + 0x1940) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_202)); } > pfls0
    .inttab_tc0_0CB (LCF_INTVEC0_START + 0x1960) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_203)); } > pfls0
    .inttab_tc0_0CC (LCF_INTVEC0_START + 0x1980) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_204)); } > pfls0
    .inttab_tc0_0CD (LCF_INTVEC0_START + 0x19A0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_205)); } > pfls0
    .inttab_tc0_0CE (LCF_INTVEC0_START + 0x19C0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_206)); } > pfls0
    .inttab_tc0_0CF (LCF_INTVEC0_START + 0x19E0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_207)); } > pfls0
    .inttab_tc0_0D0 (LCF_INTVEC0_START + 0x1A00) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_208)); } > pfls0
    .inttab_tc0_0D1 (LCF_INTVEC0_START + 0x1A20) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_209)); } > pfls0
    .inttab_tc0_0D2 (LCF_INTVEC0_START + 0x1A40) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_210)); } > pfls0
    .inttab_tc0_0D3 (LCF_INTVEC0_START + 0x1A60) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_211)); } > pfls0
    .inttab_tc0_0D4 (LCF_INTVEC0_START + 0x1A80) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_212)); } > pfls0
    .inttab_tc0_0D5 (LCF_INTVEC0_START + 0x1AA0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_213)); } > pfls0
    .inttab_tc0_0D6 (LCF_INTVEC0_START + 0x1AC0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_214)); } > pfls0
    .inttab_tc0_0D7 (LCF_INTVEC0_START + 0x1AE0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_215)); } > pfls0
    .inttab_tc0_0D8 (LCF_INTVEC0_START + 0x1B00) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_216)); } > pfls0
    .inttab_tc0_0D9 (LCF_INTVEC0_START + 0x1B20) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_217)); } > pfls0
    .inttab_tc0_0DA (LCF_INTVEC0_START + 0x1B40) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_218)); } > pfls0
    .inttab_tc0_0DB (LCF_INTVEC0_START + 0x1B60) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_219)); } > pfls0
    .inttab_tc0_0DC (LCF_INTVEC0_START + 0x1B80) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_220)); } > pfls0
    .inttab_tc0_0DD (LCF_INTVEC0_START + 0x1BA0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_221)); } > pfls0
    .inttab_tc0_0DE (LCF_INTVEC0_START + 0x1BC0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_222)); } > pfls0
    .inttab_tc0_0DF (LCF_INTVEC0_START + 0x1BE0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_223)); } > pfls0
    .inttab_tc0_0E0 (LCF_INTVEC0_START + 0x1C00) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_224)); } > pfls0
    .inttab_tc0_0E1 (LCF_INTVEC0_START + 0x1C20) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_225)); } > pfls0
    .inttab_tc0_0E2 (LCF_INTVEC0_START + 0x1C40) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_226)); } > pfls0
    .inttab_tc0_0E3 (LCF_INTVEC0_START + 0x1C60) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_227)); } > pfls0
    .inttab_tc0_0E4 (LCF_INTVEC0_START + 0x1C80) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_228)); } > pfls0
    .inttab_tc0_0E5 (LCF_INTVEC0_START + 0x1CA0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_229)); } > pfls0
    .inttab_tc0_0E6 (LCF_INTVEC0_START + 0x1CC0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_230)); } > pfls0
    .inttab_tc0_0E7 (LCF_INTVEC0_START + 0x1CE0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_231)); } > pfls0
    .inttab_tc0_0E8 (LCF_INTVEC0_START + 0x1D00) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_232)); } > pfls0
    .inttab_tc0_0E9 (LCF_INTVEC0_START + 0x1D20) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_233)); } > pfls0
    .inttab_tc0_0EA (LCF_INTVEC0_START + 0x1D40) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_234)); } > pfls0
    .inttab_tc0_0EB (LCF_INTVEC0_START + 0x1D60) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_235)); } > pfls0
    .inttab_tc0_0EC (LCF_INTVEC0_START + 0x1D80) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_236)); } > pfls0
    .inttab_tc0_0ED (LCF_INTVEC0_START + 0x1DA0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_237)); } > pfls0
    .inttab_tc0_0EE (LCF_INTVEC0_START + 0x1DC0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_238)); } > pfls0
    .inttab_tc0_0EF (LCF_INTVEC0_START + 0x1DE0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_239)); } > pfls0
    .inttab_tc0_0F0 (LCF_INTVEC0_START + 0x1E00) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_240)); } > pfls0
    .inttab_tc0_0F1 (LCF_INTVEC0_START + 0x1E20) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_241)); } > pfls0
    .inttab_tc0_0F2 (LCF_INTVEC0_START + 0x1E40) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_242)); } > pfls0
    .inttab_tc0_0F3 (LCF_INTVEC0_START + 0x1E60) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_243)); } > pfls0
    .inttab_tc0_0F4 (LCF_INTVEC0_START + 0x1E80) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_244)); } > pfls0
    .inttab_tc0_0F5 (LCF_INTVEC0_START + 0x1EA0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_245)); } > pfls0
    .inttab_tc0_0F6 (LCF_INTVEC0_START + 0x1EC0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_246)); } > pfls0
    .inttab_tc0_0F7 (LCF_INTVEC0_START + 0x1EE0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_247)); } > pfls0
    .inttab_tc0_0F8 (LCF_INTVEC0_START + 0x1F00) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_248)); } > pfls0
    .inttab_tc0_0F9 (LCF_INTVEC0_START + 0x1F20) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_249)); } > pfls0
    .inttab_tc0_0FA (LCF_INTVEC0_START + 0x1F40) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_250)); } > pfls0
    .inttab_tc0_0FB (LCF_INTVEC0_START + 0x1F60) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_251)); } > pfls0
    .inttab_tc0_0FC (LCF_INTVEC0_START + 0x1F80) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_252)); } > pfls0
    .inttab_tc0_0FD (LCF_INTVEC0_START + 0x1FA0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_253)); } > pfls0
    .inttab_tc0_0FE (LCF_INTVEC0_START + 0x1FC0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_254)); } > pfls0
    .inttab_tc0_0FF (LCF_INTVEC0_START + 0x1FE0) : { . = ALIGN() ;  KEEP (*(.intvec_tc0_255)); } > pfls0
    __INTTAB_CPU0 = LCF_INTVEC0_START;
    __INTTAB_CPU1 = LCF_INTVEC0_START; /*Single interrupt table for all CPUs*/
    __INTTAB_CPU2 = LCF_INTVEC0_START; /*Single interrupt table for all CPUs*/

    /*
     * DWARF debug sections.
     * Symbols in the DWARF debugging sections are relative to the
     * beginning of the section, so we begin them at 0.
     */
    /*
     * DWARF 1
     */
    .comment          : { *(.comment) }
    .debug            : { *(.debug) }
    .line             : { *(.line) }
    /*
     * GNU DWARF 1 extensions
     */
    .debug_srcinfo    : { *(.debug_srcinfo) }
    .debug_sfnames    : { *(.debug_sfnames) }
    /*
     * DWARF 1.1 and DWARF 2
     */
    .debug_aranges    : { *(.debug_aranges) }
    .debug_pubnames   : { *(.debug_pubnames) }
    /*
     * DWARF 2
     */
    .debug_info       : { *(.debug_info) }
    .debug_abbrev     : { *(.debug_abbrev) }
    .debug_line       : { *(.debug_line) }
    .debug_frame      : { *(.debug_frame) }
    .debug_str        : { *(.debug_str) }
    .debug_loc        : { *(.debug_loc) }
    .debug_macinfo    : { *(.debug_macinfo) }
    .debug_ranges     : { *(.debug_ranges) }
    /*
     * SGI/MIPS DWARF 2 extensions
     */
    .debug_weaknames  : { *(.debug_weaknames) }
    .debug_funcnames  : { *(.debug_funcnames) }
    .debug_typenames  : { *(.debug_typenames) }
    .debug_varnames   : { *(.debug_varnames) }
    /*
     * Optional sections that may only appear when relocating.
     */
    /*
     * Optional sections that may appear regardless of relocating.
     */
    .version_info     : { *(.version_info) }
    .boffs            : { KEEP (*(.boffs)) }
}