ENTRY( _start )

/* Configure heap and stack space reserved for application.
 * Too low may cause standard library failed,
 * too high may cause SRAM overflow.
 * Collision may occur with heap when stack gets too deep.
 */
__stack_size = 2048;
__heap_size  = 2048;

MEMORY
{
    FLASH  (rx) : ORIGIN = 0x00000000, LENGTH = 288K
    RAM   (xrw) : ORIGIN = 0x20000000, LENGTH = 32K
}


SECTIONS
{

    .init :
    {
        _sinit = .;
        . = ALIGN(4);
        KEEP(*(SORT_NONE(.init)))
        . = ALIGN(4);
        _einit = .;
    } >FLASH

  .vector :
  {
      *(.vector);
      . = ALIGN(64);
  } >FLASH

    .text :
    {
        . = ALIGN(4);
        *(.text)
        *(.text.*)
        *(.rodata)
        *(.rodata*)
        *(.glue_7)
        *(.glue_7t)
        *(.gnu.linkonce.t.*)
        . = ALIGN(4);
    } >FLASH

    .fini :
    {
        KEEP(*(SORT_NONE(.fini)))
        . = ALIGN(4);
    } >FLASH

    PROVIDE( _etext = . );
    PROVIDE( _eitcm = . );	

    .preinit_array  :
    {
      PROVIDE_HIDDEN (__preinit_array_start = .);
      KEEP (*(.preinit_array))
      PROVIDE_HIDDEN (__preinit_array_end = .);
    } >FLASH
    
    .init_array     :
    {
      PROVIDE_HIDDEN (__init_array_start = .);
      KEEP (*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))
      KEEP (*(.init_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .ctors))
      PROVIDE_HIDDEN (__init_array_end = .);
    } >FLASH
    
    .fini_array     :
    {
      PROVIDE_HIDDEN (__fini_array_start = .);
      KEEP (*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*)))
      KEEP (*(.fini_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .dtors))
      PROVIDE_HIDDEN (__fini_array_end = .);
    } >FLASH
    
    .ctors          :
    {
        /*  gcc 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))
    } >FLASH
    
    .dtors          :
    {
        KEEP (*crtbegin.o(.dtors))
        KEEP (*crtbegin?.o(.dtors))
        KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
        KEEP (*(SORT(.dtors.*)))
        KEEP (*(.dtors))
    } >FLASH

    .dalign :
    {
        . = ALIGN(4);
        PROVIDE(_data_vma = .);
    } >RAM AT>FLASH	

    .dlalign :
    {
        . = ALIGN(4); 
        PROVIDE(_data_lma = .);
    } >FLASH AT>FLASH

    .data :
    {
        *(.gnu.linkonce.r.*)
        *(.data .data.*)
        *(.gnu.linkonce.d.*)
        . = ALIGN(8);
        PROVIDE( __global_pointer$ = . + 0x800 );
        *(.sdata .sdata.*)
        *(.sdata2.*)
        *(.gnu.linkonce.s.*)
        . = ALIGN(8);
        *(.srodata.cst16)
        *(.srodata.cst8)
        *(.srodata.cst4)
        *(.srodata.cst2)
        *(.srodata .srodata.*)
        . = ALIGN(4);
        PROVIDE( _edata = .);
    } >RAM AT>FLASH

    .bss :
    {
        . = ALIGN(4);
        PROVIDE( _sbss = .);
        *(.sbss*)
        *(.gnu.linkonce.sb.*)
        *(.bss*)
        *(.gnu.linkonce.b.*)		
        *(COMMON*)
        . = ALIGN(4);
        PROVIDE(_ebss = .);
    } >RAM

    .heap_stack :
    {
        . = ALIGN(8);
        PROVIDE(_end = .);
        PROVIDE(end = . );

        . = . + __heap_size;
        . = ALIGN(8);
        PROVIDE(_heap_end = .);

        . = . + __stack_size;
        . = ALIGN(8);
    } >RAM


    /* Place initial SP to the end of SRAM */
    __stack_top = ORIGIN(RAM) + LENGTH(RAM);
    PROVIDE(_eusrstack = __stack_top);
}