9 thoughts on “Microchip Harmony and Bootloaders”

1. Pingback: Harmony LiveUpdate | Juan Gago

2. Great tutorial!. I spend like 4 days fighting to understand the bootloader procedure in Harmony. I was trying to put the bootloader and the application on the same project!. Then I read this tutorial and everything make sense now!.

   There is a warning during the compilation of the application project regarding incorrect configurations registers. This is ok given that there is no information on the boot flash section, where those configuration registers resides, after choosing the “Build and Application Linker Script?”.

   Following the tutorial I was able to implement the basic Harmony bootloader on the microcontroller PIC32MZ1024EFE064.

   Reply ↓

3. Thank you for this tutorial.
   I got the boot loader working and was able to program the hex file the application worked as expected but there is one issue that I am facing once I program the hex file I am not able to connect using AN1388 it seems like the bootloader got corrupted or something. This happens only after programming a hex file via bootloader using AN1388.
   Can you please suggest me what might have went wrong.

   Reply ↓

   • The bootloader will only run if there is nothing on the PIC, or if you initialize the bootloader somehow(for example, by holding down a button that forces the bootloader to start). Since your application is running after you program it, the AN1388 program won’t run properly.

     Reply ↓

     • Yes, thank you for replying,
       If I reset the device (turning power OFF/ON) I get the printsplash screen on the serial port application does this mean bootloader is being invoked after reset?? But still the connection fails as if bootloader directly jumps to application,Is there any way I can force start the bootloader without any botton (using interrupt of uart or something), since I am working on a custom board I dont have a provision of adding any button, all pins are being used right now.

       Reply ↓

       • U can add a uart on the bootloader project to listen for a single char or some sequence of characters at the begging for lets say 3 seconds. That could be your trigger to enter the bootloader.

         If u enable Rx interrupts u can set a flag on the uartRx ISR. If this flag is declared as a global variable, u can use it as a trigger to enter the bootloader. U will need to wait for the interrupt for a given time, after which you should skip bootloader and load the application instead. If posible try not to use the same uart used by the bootloader to transfer data. Otherwise, take care to don’t send to many characters, specially if there is a SOF (0x01) on it.

         Reply ↓

         • The other thing that you can do is to have a command that will wipe the memory that the bootloader is looking for. Since the bootloader checks a certain memory address on the flash, simply clear that memory address to force the bootloader to run the next time it boots. Pair this with a command that re-sets the PIC and you should be good.

         • Thank you,
           It worked, I erased the memory address bootloder was looking for.

4. Hello again,
   I need some help with the linker files see if you can help?
   I am able to run the application via the bootlader with interrupts disabled but when I enable the interrupts the application gets stuck (I guess jumps to some unknown memory location).
   can you suggest any solutions?

   here is my application linker
   /* 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. Can be overridden from
   * the command line using the linker’s –defsym option.
   */
   EXTERN (_min_stack_size _min_heap_size)

   /*************************************************************************
   * Processor-specific object file. Contains SFR definitions.
   *************************************************************************/
   INPUT(“processor.o”)

   /*************************************************************************
   * Processor-specific peripheral libraries are optional
   *************************************************************************/
   OPTIONAL(“libmchp_peripheral.a”)

   /*************************************************************************
   * For interrupt vector handling
   *************************************************************************/
   PROVIDE(_vector_spacing = 0x00000001);
   _ebase_address = 0x9D001000;

   /*************************************************************************
   * Memory Address Equates
   * _RESET_ADDR — Reset Vector
   * _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
   * _GEN_EXCPT_ADDR — General Exception Vector
   *************************************************************************/
   _ORIGINAL_RESET_ADDR = 0xBFC00000;
   _RESET_ADDR = (0x9D000000);
   _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.
   *************************************************************************/
   MEMORY
   {
   startup_without_bootloader : ORIGIN = 0xBFC00000, LENGTH = 0x8
   kseg0_program_mem (rx) : ORIGIN = (0x9D000000), LENGTH = 0x100000 /* All C Files will be located here */
   kseg0_boot_mem : ORIGIN = 0x9D000000, LENGTH = 0x0 /* This memory region is dummy */
   config3 : ORIGIN = 0xBFC02FF0, LENGTH = 0x4
   config2 : ORIGIN = 0xBFC02FF4, LENGTH = 0x4
   config1 : ORIGIN = 0xBFC02FF8, LENGTH = 0x4
   config0 : ORIGIN = 0xBFC02FFC, LENGTH = 0x4
   kseg1_data_mem (w!x) : ORIGIN = 0xA0000000, LENGTH = 0x40000
   sfrs : ORIGIN = 0xBF800000, LENGTH = 0x100000
   debug_exec_mem : ORIGIN = 0xBFC02000, LENGTH = 0xFF0
   configsfrs : ORIGIN = 0xBFC02FF0, LENGTH = 0x10
   }

   /*************************************************************************
   * Configuration-word sections
   *************************************************************************/
   SECTIONS
   {
   .config_BFC02FF0 : {
   KEEP(*(.config_BFC02FF0))
   } > config3
   .config_BFC02FF4 : {
   KEEP(*(.config_BFC02FF4))
   } > config2
   .config_BFC02FF8 : {
   KEEP(*(.config_BFC02FF8))
   } > config1
   .config_BFC02FFC : {
   KEEP(*(.config_BFC02FFC))
   } > config0
   }
   SECTIONS
   {
   .startup_without_bootloader _ORIGINAL_RESET_ADDR :
   {
   /* creates a ?j _reset? instruction at address _ORIGINAL_RESET_ADDR
   _reset must be within the same 256MB boundary as the original reset
   vector in order for this to work do to the limitations of the ?j? instruction.
   */
   LONG( ((_reset >> 2) & 0x03FFFFFF) | 0x08000000);
   LONG(0);
   } > startup_without_bootloader
   /* Boot Sections */
   .reset _RESET_ADDR :
   {
   KEEP(*(.reset))
   KEEP(*(.reset.startup))
   } > kseg0_program_mem
   .app_excpt _GEN_EXCPT_ADDR :
   {
   KEEP(*(.gen_handler))
   } > kseg0_program_mem

   .vector_0 _ebase_address + 0x200 :
   {
   KEEP(*(.vector_0))
   } > kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_0) <= (_vector_spacing << 5), "function at exception vector 0 too large")
   .vector_1 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_1) <= (_vector_spacing << 5), "function at exception vector 1 too large")
   .vector_2 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_2) <= (_vector_spacing << 5), "function at exception vector 2 too large")
   .vector_3 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_3) <= (_vector_spacing << 5), "function at exception vector 3 too large")
   .vector_4 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_4) <= (_vector_spacing << 5), "function at exception vector 4 too large")
   .vector_5 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_5) <= (_vector_spacing << 5), "function at exception vector 5 too large")
   .vector_6 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_6) <= (_vector_spacing << 5), "function at exception vector 6 too large")
   .vector_7 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_7) <= (_vector_spacing << 5), "function at exception vector 7 too large")
   .vector_8 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_8) <= (_vector_spacing << 5), "function at exception vector 8 too large")
   .vector_9 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_9) <= (_vector_spacing << 5), "function at exception vector 9 too large")
   .vector_10 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_10) <= (_vector_spacing << 5), "function at exception vector 10 too large")
   .vector_11 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_11) <= (_vector_spacing << 5), "function at exception vector 11 too large")
   .vector_12 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_12) <= (_vector_spacing << 5), "function at exception vector 12 too large")
   .vector_13 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_13) <= (_vector_spacing << 5), "function at exception vector 13 too large")
   .vector_14 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_14) <= (_vector_spacing << 5), "function at exception vector 14 too large")
   .vector_15 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_15) <= (_vector_spacing << 5), "function at exception vector 15 too large")
   .vector_16 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_16) <= (_vector_spacing << 5), "function at exception vector 16 too large")
   .vector_17 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_17) <= (_vector_spacing << 5), "function at exception vector 17 too large")
   .vector_18 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_18) <= (_vector_spacing << 5), "function at exception vector 18 too large")
   .vector_19 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_19) <= (_vector_spacing << 5), "function at exception vector 19 too large")
   .vector_20 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_20) <= (_vector_spacing << 5), "function at exception vector 20 too large")
   .vector_21 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_21) <= (_vector_spacing << 5), "function at exception vector 21 too large")
   .vector_22 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_22) <= (_vector_spacing << 5), "function at exception vector 22 too large")
   .vector_23 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_23) <= (_vector_spacing << 5), "function at exception vector 23 too large")
   .vector_24 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_24) <= (_vector_spacing << 5), "function at exception vector 24 too large")
   .vector_25 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_25) <= (_vector_spacing << 5), "function at exception vector 25 too large")
   .vector_26 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_26) <= (_vector_spacing << 5), "function at exception vector 26 too large")
   .vector_27 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_27) <= (_vector_spacing << 5), "function at exception vector 27 too large")
   .vector_28 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_28) <= (_vector_spacing << 5), "function at exception vector 28 too large")
   .vector_29 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_29) <= (_vector_spacing << 5), "function at exception vector 29 too large")
   .vector_30 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_30) <= (_vector_spacing << 5), "function at exception vector 30 too large")
   .vector_31 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_31) <= (_vector_spacing << 5), "function at exception vector 31 too large")
   .vector_32 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_32) <= (_vector_spacing << 5), "function at exception vector 32 too large")
   .vector_33 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_33) <= (_vector_spacing << 5), "function at exception vector 33 too large")
   .vector_34 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_34) <= (_vector_spacing << 5), "function at exception vector 34 too large")
   .vector_35 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_35) <= (_vector_spacing << 5), "function at exception vector 35 too large")
   .vector_36 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_36) <= (_vector_spacing << 5), "function at exception vector 36 too large")
   .vector_37 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_37) <= (_vector_spacing << 5), "function at exception vector 37 too large")
   .vector_38 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_38) <= (_vector_spacing << 5), "function at exception vector 38 too large")
   .vector_39 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_39) <= (_vector_spacing << 5), "function at exception vector 39 too large")
   .vector_40 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_40) <= (_vector_spacing << 5), "function at exception vector 40 too large")
   .vector_41 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_41) <= (_vector_spacing << 5), "function at exception vector 41 too large")
   .vector_42 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_42) <= (_vector_spacing << 5), "function at exception vector 42 too large")
   .vector_43 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_43) <= (_vector_spacing << 5), "function at exception vector 43 too large")
   .vector_44 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_44) <= (_vector_spacing << 5), "function at exception vector 44 too large")
   .vector_45 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_45) <= (_vector_spacing << 5), "function at exception vector 45 too large")
   .vector_46 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_46) <= (_vector_spacing << 5), "function at exception vector 46 too large")
   .vector_47 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_47) <= (_vector_spacing << 5), "function at exception vector 47 too large")
   .vector_48 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_48) <= (_vector_spacing << 5), "function at exception vector 48 too large")
   .vector_49 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_49) <= (_vector_spacing << 5), "function at exception vector 49 too large")
   .vector_50 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_50) <= (_vector_spacing << 5), "function at exception vector 50 too large")
   .vector_51 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_51) <= (_vector_spacing << 5), "function at exception vector 51 too large")
   .vector_52 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_52) <= (_vector_spacing << 5), "function at exception vector 52 too large")
   .vector_53 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_53) <= (_vector_spacing << 5), "function at exception vector 53 too large")
   .vector_54 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_54) <= (_vector_spacing << 5), "function at exception vector 54 too large")
   .vector_55 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_55) <= (_vector_spacing << 5), "function at exception vector 55 too large")
   .vector_56 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_56) <= (_vector_spacing << 5), "function at exception vector 56 too large")
   .vector_57 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_57) <= (_vector_spacing << 5), "function at exception vector 57 too large")
   .vector_58 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_58) <= (_vector_spacing << 5), "function at exception vector 58 too large")
   .vector_59 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_59) <= (_vector_spacing << 5), "function at exception vector 59 too large")
   .vector_60 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_60) <= (_vector_spacing << 5), "function at exception vector 60 too large")
   .vector_61 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_61) <= (_vector_spacing << 5), "function at exception vector 61 too large")
   .vector_62 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_62) <= (_vector_spacing << 5), "function at exception vector 62 too large")
   .vector_63 _ebase_address + 0x200 + (_vector_spacing < kseg0_program_mem
   ASSERT (_vector_spacing == 0 || SIZEOF(.vector_63) <= (_vector_spacing < kseg0_boot_mem
   /* Code Sections – Note that input sections *(.text) and *(.text.*)
   ** are not mapped here. Starting in C32 v2.00, 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 .sbss, which contains
   * small non-initialized, non-constant global and static data.
   */
   .sbss2 ALIGN(4) :
   {
   *(.sbss2 .sbss2.* .gnu.linkonce.sb2.*)
   . = 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);
   } >kseg1_data_mem
   .jcr :
   {
   KEEP (*(.jcr))
   . = ALIGN(4) ;
   } >kseg1_data_mem
   .eh_frame : ONLY_IF_RW
   {
   KEEP (*(.eh_frame))
   } >kseg1_data_mem
   . = ALIGN(4) ;
   .gcc_except_table : ONLY_IF_RW
   {
   *(.gcc_except_table .gcc_except_table.*)
   } >kseg1_data_mem
   . = ALIGN(4) ;
   /* Persistent data – Use the new C ‘persistent’ attribute instead. */
   .persist :
   {
   _persist_begin = .;
   *(.persist .persist.*)
   *(.pbss .pbss.*)
   . = ALIGN(4) ;
   _persist_end = .;
   } >kseg1_data_mem
   /*
   * Note that input sections named .data* are no longer mapped here.
   * Starting in C32 v2.00, 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) ;
   } >kseg1_data_mem
   . = .;
   _gp = ALIGN(16) + 0x7ff0;
   .got ALIGN(4) :
   {
   *(.got.plt) *(.got)
   . = ALIGN(4) ;
   } >kseg1_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 = . ;
   } >kseg1_data_mem
   .lit8 :
   {
   *(.lit8)
   } >kseg1_data_mem
   .lit4 :
   {
   *(.lit4)
   } >kseg1_data_mem
   . = ALIGN (4) ;
   _data_end = . ;
   _bss_begin = . ;
   .sbss ALIGN(4) :
   {
   _sbss_begin = . ;
   *(.dynsbss)
   *(.sbss .sbss.* .gnu.linkonce.sb.*)
   *(.scommon)
   _sbss_end = . ;
   . = ALIGN(4) ;
   } >kseg1_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.
   * Starting in C32 v2.00, 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);
   } >kseg1_data_mem
   . = ALIGN(4) ;
   _end = . ;
   _bss_end = . ;
   /* Starting with C32 v2.00, the heap and stack are dynamically
   * allocated by the linker.
   */
   /*
   * 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(kseg1_data_mem) ;
   _bmxdupba_address = LENGTH(kseg1_data_mem) ;
   /* The .pdr section belongs in the absolute section */
   /DISCARD/ : { *(.pdr) }
   .gptab.sdata : { *(.gptab.data) *(.gptab.sdata) }
   .gptab.sbss : { *(.gptab.bss) *(.gptab.sbss) }
   .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.
   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) }

   }

   Reply ↓