2714
评论
淘帖
1633
9fc01140: 4fb0 addiu sp,sp,-8
//------------------------------------------------------------------------------
// Main Function
//------------------------------------------------------------------------------
int main(void)
{
9fc01142: cbc1 sw s8,4(sp)
9fc01144: 0fdd move s8,sp
9fc01146: 0000 0800 ssnop
while(1)
{
Nop();
9fc0114a: cffd b 9fc01146
}
9fc0114c: 0c00 nop
9fc0114e: 0c00 nop
Disassembly of section .dinit:
9fc01150 <.dinit>:
9fc01150: 00000000 nop
9fc01154: 22222222 addi v0,s1,8738
9fc01158: 22222222 addi v0,s1,8738
9fc0115c: 22222222 addi v0,s1,8738
Disassembly of section .text._on_reset:
9fc01160 <_on_reset>:
9fc01160: 45bf jrc ra
9fc01162 <.LFE0>:
9fc01162: Address 0x9fc01162 is out of bounds.
Disassembly of section .text._on_bootstrap:
9fc01164 <_on_bootstrap>:
9fc01164: 45bf jrc ra
9fc01166 <.LFE0>:
9fc01166: Address 0x9fc01166 is out of bounds.
Current linker script:
/*--------------------------------------------------------------------------
* MPLAB XC Compiler - PIC32MM0064GPL036 linker script
* Build date : Jun 01 2016
*
* Copyright (c) 2016, Microchip Technology Inc. and its subsidiaries ("Microchip")
* All rights reserved.
*
* This software is developed by Microchip Technology Inc. and its
* subsidiaries ("Microchip").
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* 3. Microchip's name may not be used to endorse or promote products
* derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY MICROCHIP "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR PURPOSE ARE DISCLAIMED. IN NO EVENT
* SHALL MICROCHIP BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING BUT NOT LIMITED TO
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWSOEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/* Default linker script, for normal executables */
OUTPUT_FORMAT("elf32-tradlittlemips")
OUTPUT_ARCH(pic32mx)
ENTRY(_reset)
/*
* Provide for a minimum stack and heap size
* - _min_stack_size - represents the minimum space that must be made
* available for the stack. Can be overridden from
* the command line using the linker's --defsym option.
* - _min_heap_size - represents the minimum space that must be made
* available for the heap. Must be specified on
* the command line using the linker's --defsym option.
*/
EXTERN (_min_stack_size _min_heap_size)
PROVIDE(_min_stack_size = 0x400) ;
/*************************************************************************
* Processor-specific object file. Contains SFR definitions.
*************************************************************************/
INPUT("processor.o")
/*************************************************************************
* Symbols used for interrupt-vector table generation
* To override the defaults, define the _vector_spacing & _ebase_address
* symbols using the --defsym linker opt as shown in these examples:
* xc32-gcc src.c -Wl,--defsym=_vector_spacing=2
* xc32-gcc src.c -Wl,--defsym=_ebase_address=0x9D001000
*************************************************************************/
PROVIDE(_vector_spacing = 0x0001);
PROVIDE(_ebase_address = 0x9FC01000);
/*************************************************************************
* Memory Address Equates
* _RESET_ADDR -- Reset Vector or entry point
* _BEV_EXCPT_ADDR -- Boot exception Vector
* _DBG_EXCPT_ADDR -- In-circuit Debugging Exception Vector
* _DBG_CODE_ADDR -- In-circuit Debug Executive address
* _DBG_CODE_SIZE -- In-circuit Debug Executive size
* _SIMPLE_TLB_REFILL_EXCPT_ADDR -- Simple TLB-Refill Exception Vector
* _GEN_EXCPT_ADDR -- General Exception Vector
*************************************************************************/
_RESET_ADDR = 0xBFC00000;
_BEV_EXCPT_ADDR = 0xBFC00380;
_DBG_EXCPT_ADDR = 0xBFC00480;
_DBG_CODE_ADDR = 0x9FC00490;
_DBG_CODE_SIZE = 0x760;
_SIMPLE_TLB_REFILL_EXCPT_ADDR = _ebase_address + 0;
_GEN_EXCPT_ADDR = _ebase_address + 0x180;
/*************************************************************************
* Memory Regions
*
* Memory regions without attributes cannot be used for orphaned sections.
* Only sections specifically assigned to these regions can be allocated
* into these regions.
*
* The Debug exception vector is located at 0x9FC00480.
*
* The config_ sections are used to locate the config words at
* their absolute addresses.
*************************************************************************/
MEMORY
{
kseg0_program_mem (rx) : ORIGIN = 0x9FC01000, LENGTH = 0x1700 - 0x1000
debug_exec_mem : ORIGIN = 0x9FC00490, LENGTH = 0x760
kseg0_boot_mem : ORIGIN = 0x9FC00490, LENGTH = 0x0
kseg1_boot_mem : ORIGIN = 0xBFC00000, LENGTH = 0x490
config_BFC01704 : ORIGIN = 0xBFC01704, LENGTH = 0x4
config_BFC01708 : ORIGIN = 0xBFC01708, LENGTH = 0x4
config_BFC0170C : ORIGIN = 0xBFC0170C, LENGTH = 0x4
config_BFC01710 : ORIGIN = 0xBFC01710, LENGTH = 0x4
config_BFC01714 : ORIGIN = 0xBFC01714, LENGTH = 0x4
config_BFC01718 : ORIGIN = 0xBFC01718, LENGTH = 0x4
config_BFC01720 : ORIGIN = 0xBFC01720, LENGTH = 0x4
config_BFC017C4 : ORIGIN = 0xBFC017C4, LENGTH = 0x4
config_BFC017C8 : ORIGIN = 0xBFC017C8, LENGTH = 0x4
config_BFC017CC : ORIGIN = 0xBFC017CC, LENGTH = 0x4
config_BFC017D0 : ORIGIN = 0xBFC017D0, LENGTH = 0x4
config_BFC017D4 : ORIGIN = 0xBFC017D4, LENGTH = 0x4
config_BFC017D8 : ORIGIN = 0xBFC017D8, LENGTH = 0x4
config_BFC017E0 : ORIGIN = 0xBFC017E0, LENGTH = 0x4
kseg0_data_mem (w!x) : ORIGIN = 0x80000000, LENGTH = 0x2000
sfrs : ORIGIN = 0xBF800000, LENGTH = 0x100000
configsfrs_BFC01700 : ORIGIN = 0xBFC01700, LENGTH = 0x1C
configsfrs_BFC017C0 : ORIGIN = 0xBFC017C0, LENGTH = 0x1C
}
/*************************************************************************
* Configuration-word sections. Map the config-pragma input sections to
* absolute-address output sections.
*************************************************************************/
SECTIONS
{
.config_BFC01704 : {
KEEP(*(.config_BFC01704))
} > config_BFC01704
.config_BFC01708 : {
KEEP(*(.config_BFC01708))
} > config_BFC01708
.config_BFC0170C : {
KEEP(*(.config_BFC0170C))
} > config_BFC0170C
.config_BFC01710 : {
KEEP(*(.config_BFC01710))
} > config_BFC01710
.config_BFC01714 : {
KEEP(*(.config_BFC01714))
} > config_BFC01714
.config_BFC01718 : {
KEEP(*(.config_BFC01718))
} > config_BFC01718
.config_BFC01720 : {
KEEP(*(.config_BFC01720))
} > config_BFC01720
.config_BFC017C4 : {
KEEP(*(.config_BFC017C4))
} > config_BFC017C4
.config_BFC017C8 : {
KEEP(*(.config_BFC017C8))
} > config_BFC017C8
.config_BFC017CC : {
KEEP(*(.config_BFC017CC))
} > config_BFC017CC
.config_BFC017D0 : {
KEEP(*(.config_BFC017D0))
} > config_BFC017D0
.config_BFC017D4 : {
KEEP(*(.config_BFC017D4))
} > config_BFC017D4
.config_BFC017D8 : {
KEEP(*(.config_BFC017D8))
} > config_BFC017D8
.config_BFC017E0 : {
KEEP(*(.config_BFC017E0))
} > config_BFC017E0
}
SECTIONS
{
/* Boot Sections */
.reset _RESET_ADDR :
{
KEEP(*(.reset))
KEEP(*(.reset.startup))
} > kseg1_boot_mem
.bev_excpt _BEV_EXCPT_ADDR :
{
KEEP(*(.bev_handler))
} > kseg1_boot_mem
/* Debug exception vector */
.dbg_excpt _DBG_EXCPT_ADDR (NOLOAD) :
{
. += (DEFINED (_DEBUGGER) ? 0x8 : 0x0);
} > kseg1_boot_mem
/* Space reserved for the debug executive */
.dbg_code _DBG_CODE_ADDR (NOLOAD) :
{
. += (DEFINED (_DEBUGGER) ? _DBG_CODE_SIZE : 0x0);
} > debug_exec_mem
.app_excpt _GEN_EXCPT_ADDR :
{
KEEP(*(.gen_handler))
} > kseg0_program_mem
.vector_0 _ebase_address + 0x200 + ((_vector_spacing << 3) * 0) :
{
KEEP(*(.vector_0))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_0) <= (_vector_spacing << 3), "function at exception vector 0 too large")
.vector_1 _ebase_address + 0x200 + ((_vector_spacing << 3) * 1) :
{
KEEP(*(.vector_1))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_1) <= (_vector_spacing << 3), "function at exception vector 1 too large")
.vector_2 _ebase_address + 0x200 + ((_vector_spacing << 3) * 2) :
{
KEEP(*(.vector_2))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_2) <= (_vector_spacing << 3), "function at exception vector 2 too large")
.vector_3 _ebase_address + 0x200 + ((_vector_spacing << 3) * 3) :
{
KEEP(*(.vector_3))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_3) <= (_vector_spacing << 3), "function at exception vector 3 too large")
.vector_4 _ebase_address + 0x200 + ((_vector_spacing << 3) * 4) :
{
KEEP(*(.vector_4))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_4) <= (_vector_spacing << 3), "function at exception vector 4 too large")
.vector_5 _ebase_address + 0x200 + ((_vector_spacing << 3) * 5) :
{
KEEP(*(.vector_5))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_5) <= (_vector_spacing << 3), "function at exception vector 5 too large")
.vector_6 _ebase_address + 0x200 + ((_vector_spacing << 3) * 6) :
{
KEEP(*(.vector_6))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_6) <= (_vector_spacing << 3), "function at exception vector 6 too large")
.vector_7 _ebase_address + 0x200 + ((_vector_spacing << 3) * 7) :
{
KEEP(*(.vector_7))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_7) <= (_vector_spacing << 3), "function at exception vector 7 too large")
.vector_8 _ebase_address + 0x200 + ((_vector_spacing << 3) * 8) :
{
KEEP(*(.vector_8))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_8) <= (_vector_spacing << 3), "function at exception vector 8 too large")
.vector_9 _ebase_address + 0x200 + ((_vector_spacing << 3) * 9) :
{
KEEP(*(.vector_9))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_9) <= (_vector_spacing << 3), "function at exception vector 9 too large")
.vector_10 _ebase_address + 0x200 + ((_vector_spacing << 3) * 10) :
{
KEEP(*(.vector_10))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_10) <= (_vector_spacing << 3), "function at exception vector 10 too large")
.vector_11 _ebase_address + 0x200 + ((_vector_spacing << 3) * 11) :
{
KEEP(*(.vector_11))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_11) <= (_vector_spacing << 3), "function at exception vector 11 too large")
.vector_12 _ebase_address + 0x200 + ((_vector_spacing << 3) * 12) :
{
KEEP(*(.vector_12))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_12) <= (_vector_spacing << 3), "function at exception vector 12 too large")
.vector_13 _ebase_address + 0x200 + ((_vector_spacing << 3) * 13) :
{
KEEP(*(.vector_13))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_13) <= (_vector_spacing << 3), "function at exception vector 13 too large")
.vector_14 _ebase_address + 0x200 + ((_vector_spacing << 3) * 14) :
{
KEEP(*(.vector_14))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_14) <= (_vector_spacing << 3), "function at exception vector 14 too large")
.vector_15 _ebase_address + 0x200 + ((_vector_spacing << 3) * 15) :
{
KEEP(*(.vector_15))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_15) <= (_vector_spacing << 3), "function at exception vector 15 too large")
.vector_16 _ebase_address + 0x200 + ((_vector_spacing << 3) * 16) :
{
KEEP(*(.vector_16))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_16) <= (_vector_spacing << 3), "function at exception vector 16 too large")
.vector_17 _ebase_address + 0x200 + ((_vector_spacing << 3) * 17) :
{
KEEP(*(.vector_17))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_17) <= (_vector_spacing << 3), "function at exception vector 17 too large")
.vector_18 _ebase_address + 0x200 + ((_vector_spacing << 3) * 18) :
{
KEEP(*(.vector_18))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_18) <= (_vector_spacing << 3), "function at exception vector 18 too large")
.vector_19 _ebase_address + 0x200 + ((_vector_spacing << 3) * 19) :
{
KEEP(*(.vector_19))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_19) <= (_vector_spacing << 3), "function at exception vector 19 too large")
.vector_20 _ebase_address + 0x200 + ((_vector_spacing << 3) * 20) :
{
KEEP(*(.vector_20))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_20) <= (_vector_spacing << 3), "function at exception vector 20 too large")
.vector_21 _ebase_address + 0x200 + ((_vector_spacing << 3) * 21) :
{
KEEP(*(.vector_21))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_21) <= (_vector_spacing << 3), "function at exception vector 21 too large")
.vector_22 _ebase_address + 0x200 + ((_vector_spacing << 3) * 22) :
{
KEEP(*(.vector_22))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_22) <= (_vector_spacing << 3), "function at exception vector 22 too large")
.vector_23 _ebase_address + 0x200 + ((_vector_spacing << 3) * 23) :
{
KEEP(*(.vector_23))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_23) <= (_vector_spacing << 3), "function at exception vector 23 too large")
.vector_24 _ebase_address + 0x200 + ((_vector_spacing << 3) * 24) :
{
KEEP(*(.vector_24))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_24) <= (_vector_spacing << 3), "function at exception vector 24 too large")
.vector_25 _ebase_address + 0x200 + ((_vector_spacing << 3) * 25) :
{
KEEP(*(.vector_25))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_25) <= (_vector_spacing << 3), "function at exception vector 25 too large")
.vector_26 _ebase_address + 0x200 + ((_vector_spacing << 3) * 26) :
{
KEEP(*(.vector_26))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_26) <= (_vector_spacing << 3), "function at exception vector 26 too large")
.vector_27 _ebase_address + 0x200 + ((_vector_spacing << 3) * 27) :
{
KEEP(*(.vector_27))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_27) <= (_vector_spacing << 3), "function at exception vector 27 too large")
.vector_28 _ebase_address + 0x200 + ((_vector_spacing << 3) * 28) :
{
KEEP(*(.vector_28))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_28) <= (_vector_spacing << 3), "function at exception vector 28 too large")
.vector_29 _ebase_address + 0x200 + ((_vector_spacing << 3) * 29) :
{
KEEP(*(.vector_29))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_29) <= (_vector_spacing << 3), "function at exception vector 29 too large")
.vector_30 _ebase_address + 0x200 + ((_vector_spacing << 3) * 30) :
{
KEEP(*(.vector_30))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_30) <= (_vector_spacing << 3), "function at exception vector 30 too large")
.vector_31 _ebase_address + 0x200 + ((_vector_spacing << 3) * 31) :
{
KEEP(*(.vector_31))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_31) <= (_vector_spacing << 3), "function at exception vector 31 too large")
.vector_32 _ebase_address + 0x200 + ((_vector_spacing << 3) * 32) :
{
KEEP(*(.vector_32))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_32) <= (_vector_spacing << 3), "function at exception vector 32 too large")
.vector_33 _ebase_address + 0x200 + ((_vector_spacing << 3) * 33) :
{
KEEP(*(.vector_33))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_33) <= (_vector_spacing << 3), "function at exception vector 33 too large")
.vector_34 _ebase_address + 0x200 + ((_vector_spacing << 3) * 34) :
{
KEEP(*(.vector_34))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_34) <= (_vector_spacing << 3), "function at exception vector 34 too large")
.vector_35 _ebase_address + 0x200 + ((_vector_spacing << 3) * 35) :
{
KEEP(*(.vector_35))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_35) <= (_vector_spacing << 3), "function at exception vector 35 too large")
.vector_36 _ebase_address + 0x200 + ((_vector_spacing << 3) * 36) :
{
KEEP(*(.vector_36))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_36) <= (_vector_spacing << 3), "function at exception vector 36 too large")
.vector_37 _ebase_address + 0x200 + ((_vector_spacing << 3) * 37) :
{
KEEP(*(.vector_37))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_37) <= (_vector_spacing << 3), "function at exception vector 37 too large")
.vector_38 _ebase_address + 0x200 + ((_vector_spacing << 3) * 38) :
{
KEEP(*(.vector_38))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_38) <= (_vector_spacing << 3), "function at exception vector 38 too large")
.vector_39 _ebase_address + 0x200 + ((_vector_spacing << 3) * 39) :
{
KEEP(*(.vector_39))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_39) <= (_vector_spacing << 3), "function at exception vector 39 too large")
.vector_40 _ebase_address + 0x200 + ((_vector_spacing << 3) * 40) :
{
KEEP(*(.vector_40))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_40) <= (_vector_spacing << 3), "function at exception vector 40 too large")
.vector_41 _ebase_address + 0x200 + ((_vector_spacing << 3) * 41) :
{
KEEP(*(.vector_41))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_41) <= (_vector_spacing << 3), "function at exception vector 41 too large")
.vector_42 _ebase_address + 0x200 + ((_vector_spacing << 3) * 42) :
{
KEEP(*(.vector_42))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_42) <= (_vector_spacing << 3), "function at exception vector 42 too large")
.vector_43 _ebase_address + 0x200 + ((_vector_spacing << 3) * 43) :
{
KEEP(*(.vector_43))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_43) <= (_vector_spacing << 3), "function at exception vector 43 too large")
.vector_44 _ebase_address + 0x200 + ((_vector_spacing << 3) * 44) :
{
KEEP(*(.vector_44))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_44) <= (_vector_spacing << 3), "function at exception vector 44 too large")
.vector_45 _ebase_address + 0x200 + ((_vector_spacing << 3) * 45) :
{
KEEP(*(.vector_45))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_45) <= (_vector_spacing << 3), "function at exception vector 45 too large")
.vector_46 _ebase_address + 0x200 + ((_vector_spacing << 3) * 46) :
{
KEEP(*(.vector_46))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_46) <= (_vector_spacing << 3), "function at exception vector 46 too large")
.vector_47 _ebase_address + 0x200 + ((_vector_spacing << 3) * 47) :
{
KEEP(*(.vector_47))
} > kseg0_program_mem
ASSERT (_vector_spacing == 0 || SIZEOF(.vector_47) <= (_vector_spacing << 3), "function at exception vector 47 too large")
/* The startup code is in the .reset.startup section.
* Keep this here for backwards compatibility with older
* C32 v1.xx releases.
*/
.startup ORIGIN(kseg0_boot_mem) :
{
KEEP(*(.startup))
} > kseg0_boot_mem
/* Code Sections - Note that input sections *(.text) and *(.text.*)
* are not mapped here. The best-fit allocator locates them,
* so that .text may flow around absolute sections as needed.
*/
.text :
{
*(.stub .gnu.linkonce.t.*)
KEEP (*(.text.*personality*))
*(.mips16.fn.*)
*(.mips16.call.*)
*(.gnu.warning)
. = ALIGN(4) ;
} >kseg0_program_mem
/* Global-namespace object initialization */
.init :
{
KEEP (*crti.o(.init))
KEEP (*crtbegin.o(.init))
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o *crtn.o ).init))
KEEP (*crtend.o(.init))
KEEP (*crtn.o(.init))
. = ALIGN(4) ;
} >kseg0_program_mem
.fini :
{
KEEP (*(.fini))
. = ALIGN(4) ;
} >kseg0_program_mem
.preinit_array :
{
PROVIDE_HIDDEN (__preinit_array_start = .);
KEEP (*(.preinit_array))
PROVIDE_HIDDEN (__preinit_array_end = .);
. = ALIGN(4) ;
} >kseg0_program_mem
.init_array :
{
PROVIDE_HIDDEN (__init_array_start = .);
KEEP (*(SORT(.init_array.*)))
KEEP (*(.init_array))
PROVIDE_HIDDEN (__init_array_end = .);
. = ALIGN(4) ;
} >kseg0_program_mem
.fini_array :
{
PROVIDE_HIDDEN (__fini_array_start = .);
KEEP (*(SORT(.fini_array.*)))
KEEP (*(.fini_array))
PROVIDE_HIDDEN (__fini_array_end = .);
. = ALIGN(4) ;
} >kseg0_program_mem
.ctors :
{
/* XC32 uses crtbegin.o to find the start of
the constructors, so we make sure it is
first. Because this is a wildcard, it
doesn't matter if the user does not
actually link against crtbegin.o; the
linker won't look for a file to match a
wildcard. The wildcard also means that it
doesn't matter which directory crtbegin.o
is in. */
KEEP (*crtbegin.o(.ctors))
KEEP (*crtbegin?.o(.ctors))
/* We don't want to include the .ctor section from
the crtend.o file until after the sorted ctors.
The .ctor section from the crtend file contains the
end of ctors marker and it must be last */
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
KEEP (*(SORT(.ctors.*)))
KEEP (*(.ctors))
. = ALIGN(4) ;
} >kseg0_program_mem
.dtors :
{
KEEP (*crtbegin.o(.dtors))
KEEP (*crtbegin?.o(.dtors))
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
KEEP (*(SORT(.dtors.*)))
KEEP (*(.dtors))
. = ALIGN(4) ;
} >kseg0_program_mem
/* Read-only sections */
.rodata :
{
*( .gnu.linkonce.r.*)
*(.rodata1)
. = ALIGN(4) ;
} >kseg0_program_mem
/*
* Small initialized constant global and static data can be placed in the
* .sdata2 section. This is different from .sdata, which contains small
* initialized non-constant global and static data.
*/
.sdata2 ALIGN(4) :
{
*(.sdata2 .sdata2.* .gnu.linkonce.s2.*)
. = ALIGN(4) ;
} >kseg0_program_mem
/*
* Uninitialized constant global and static data (i.e., variables which will
* always be zero). Again, this is different from .***ss, which contains
* small non-initialized, non-constant global and static data.
*/
.***ss2 ALIGN(4) :
{
*(.***ss2 .***ss2.* .gnu.linkonce.***2.*)
. = ALIGN(4) ;
} >kseg0_program_mem
.eh_frame_hdr :
{
*(.eh_frame_hdr)
} >kseg0_program_mem
. = ALIGN(4) ;
.eh_frame : ONLY_IF_RO
{
KEEP (*(.eh_frame))
} >kseg0_program_mem
. = ALIGN(4) ;
.gcc_except_table : ONLY_IF_RO
{
*(.gcc_except_table .gcc_except_table.*)
} >kseg0_program_mem
. = ALIGN(4) ;
.dbg_data (NOLOAD) :
{
. += (DEFINED (_DEBUGGER) ? 0x200 : 0x0);
} >kseg0_data_mem
.jcr :
{
KEEP (*(.jcr))
. = ALIGN(4) ;
} >kseg0_data_mem
.eh_frame : ONLY_IF_RW
{
KEEP (*(.eh_frame))
} >kseg0_data_mem
. = ALIGN(4) ;
.gcc_except_table : ONLY_IF_RW
{
*(.gcc_except_table .gcc_except_table.*)
} >kseg0_data_mem
. = ALIGN(4) ;
/* Persistent data - Use the new C 'persistent' attribute instead. */
.persist :
{
_persist_begin = .;
*(.persist .persist.*)
*(.pbss .pbss.*)
. = ALIGN(4) ;
_persist_end = .;
} >kseg0_data_mem
/*
* Note that input sections named .data* are not mapped here.
* The best-fit allocator locates them, so that they may flow
* around absolute sections as needed.
*/
.data :
{
*( .gnu.linkonce.d.*)
SORT(CONSTRUCTORS)
*(.data1)
. = ALIGN(4) ;
} >kseg0_data_mem
. = .;
_gp = ALIGN(16) + 0x7ff0;
.got ALIGN(4) :
{
*(.got.plt) *(.got)
. = ALIGN(4) ;
} >kseg0_data_mem /* AT>kseg0_program_mem */
/*
* Note that 'small' data sections are still mapped in the linker
* script. This ensures that they are grouped together for
* gp-relative addressing. Absolute sections are allocated after
* the 'small' data sections so small data cannot flow around them.
*/
/*
* We want the small data sections together, so single-instruction offsets
* can access them all, and initialized data all before uninitialized, so
* we can shorten the on-disk segment size.
*/
.sdata ALIGN(4) :
{
_sdata_begin = . ;
*(.sdata .sdata.* .gnu.linkonce.s.*)
. = ALIGN(4) ;
_sdata_end = . ;
} >kseg0_data_mem
.lit8 :
{
*(.lit8)
} >kseg0_data_mem
.lit4 :
{
*(.lit4)
} >kseg0_data_mem
. = ALIGN (4) ;
_data_end = . ;
_bss_begin = . ;
.***ss ALIGN(4) :
{
_***ss_begin = . ;
*(.dyn***ss)
*(.***ss .***ss.* .gnu.linkonce.***.*)
*(.scommon)
_***ss_end = . ;
. = ALIGN(4) ;
} >kseg0_data_mem
/*
* Align here to ensure that the .bss section occupies space up to
* _end. Align after .bss to ensure correct alignment even if the
* .bss section disappears because there are no input sections.
*
* Note that input sections named .bss* are no longer mapped here.
* The best-fit allocator locates them, so that they may flow
* around absolute sections as needed.
*
*/
.bss :
{
*(.dynbss)
*(COMMON)
/* Align here to ensure that the .bss section occupies space up to
_end. Align after .bss to ensure correct alignment even if the
.bss section disappears because there are no input sections. */
. = ALIGN(. != 0 ? 4 : 1);
} >kseg0_data_mem
. = ALIGN(4) ;
_end = . ;
_bss_end = . ;
/*
* The heap and stack are best-fit allocated by the linker after other
* data and bss sections have been allocated.
*/
/*
* RAM functions go at the end of our stack and heap allocation.
* Alignment of 2K required by the boundary register (BMXDKPBA).
*
* RAM functions are now allocated by the linker. The linker generates
* _ramfunc_begin and _bmxdkpba_address symbols depending on the
* location of RAM functions.
*/
_bmxdudba_address = LENGTH(kseg0_data_mem) ;
_bmxdupba_address = LENGTH(kseg0_data_mem) ;
/* The .pdr section belongs in the absolute section */
/DISCARD/ : { *(.pdr) }
.gptab.sdata : { *(.gptab.data) *(.gptab.sdata) }
.gptab.***ss : { *(.gptab.bss) *(.gptab.***ss) }
.mdebug.abi32 : { KEEP(*(.mdebug.abi32)) }
.mdebug.abiN32 : { KEEP(*(.mdebug.abiN32)) }
.mdebug.abi64 : { KEEP(*(.mdebug.abi64)) }
.mdebug.abiO64 : { KEEP(*(.mdebug.abiO64)) }
.mdebug.eabi32 : { KEEP(*(.mdebug.eabi32)) }
.mdebug.eabi64 : { KEEP(*(.mdebug.eabi64)) }
.gcc_compiled_long32 : { KEEP(*(.gcc_compiled_long32)) }
.gcc_compiled_long64 : { KEEP(*(.gcc_compiled_long64)) }
/* Stabs debugging sections. */
.stab 0 : { *(.stab) }
.stabstr 0 : { *(.stabstr) }
.stab.excl 0 : { *(.stab.excl) }
.stab.exclstr 0 : { *(.stab.exclstr) }
.stab.index 0 : { *(.stab.index) }
.stab.indexstr 0 : { *(.stab.indexstr) }
.comment 0 : { *(.comment) }
/* DWARF debug sections used by MPLAB X for source-level debugging.
Symbols in the DWARF debugging sections are relative to the beginning
of the section so we begin them at 0. */
/* DWARF 1 */
.debug 0 : { *(.debug) }
.line 0 : { *(.line) }
/* GNU DWARF 1 extensions */
.debug_srcinfo 0 : { *(.debug_srcinfo) }
.debug_sfnames 0 : { *(.debug_sfnames) }
/* DWARF 1.1 and DWARF 2 */
.debug_aranges 0 : { *(.debug_aranges) }
.debug_pubnames 0 : { *(.debug_pubnames) }
/* DWARF 2 */
.debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) }
.debug_abbrev 0 : { *(.debug_abbrev) }
.debug_line 0 : { *(.debug_line) }
.debug_frame 0 : { *(.debug_frame) }
.debug_str 0 : { *(.debug_str) }
.debug_loc 0 : { *(.debug_loc) }
.debug_macinfo 0 : { *(.debug_macinfo) }
/* SGI/MIPS DWARF 2 extensions */
.debug_weaknames 0 : { *(.debug_weaknames) }
.debug_funcnames 0 : { *(.debug_funcnames) }
.debug_typenames 0 : { *(.debug_typenames) }
.debug_varnames 0 : { *(.debug_varnames) }
.debug_pubtypes 0 : { *(.debug_pubtypes) }
.debug_ranges 0 : { *(.debug_ranges) }
/DISCARD/ : { *(.rel.dyn) }
.gnu.attributes 0 : { KEEP (*(.gnu.attributes)) }
/DISCARD/ : { *(.note.GNU-stack) }
/DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) *(.discard) }
}
Thanks again!
/6 
工商网监
