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)) }
}