I have the following linker script:
`.data` &amp; `.bss` are placed into ram, then a `.heap` section fills the remaining memory.

Now I want to add a `.noinit` section that always gets placed at the end of the memory. That is so it gets ignored by bootloaders and the like.

I still want my `.heap` section to occupy all available space between `.bss` and `.noinit`, but for this I need to know the size of the `.noinit` section.

A naive approach failed:

    /* .bss section which is used for uninitialized data */
    .bss (NOLOAD) :
    {
        . = ALIGN(4);
        _sbss = . ;
        _szero = .;
        *(.bss .bss.*)
        *(COMMON)
        . = ALIGN(4);
        _ebss = . ;
        _ezero = .;
    } &gt; ram

    /* heap section */
    .heap (NOLOAD) :
    {
        . = ALIGN(4);
        _sheap = . ;
        . = ORIGIN(ram) + LENGTH(ram) - SIZEOF(.noinit);
        _eheap = . ;
    }  &gt; ram

    /*
     * collect all uninitialized sections that go into RAM
     */
    .noinit (NOLOAD) :
    {
        . = ALIGN(4);
        __noinit_start = .;
        *(.noinit)
        __noinit_end = .;
    }  &gt; ram

Here `SIZEOF(.noinit)` is always 0 because the section is defined after that statement.

But in fact what I want is `SIZEOF(*(.noinit))` - however this is a syntax error.

So how do I get the size of an input section without placing it into an output section first?

How to get the size of an input section (to place it at the end of memory)

The [LD manual](http://ftp.gnu.org/old-gnu/Manuals/ld-2.9.1/html_mono/ld.html#SEC2) does not explain what the `KEEP` command does. Below is a snippet from a third-party linker script that features `KEEP`. What does the `KEEP` command do in `ld`?

    SECTIONS
    {  
        .text :
        {
            . = ALIGN(4);
            _text = .;
            PROVIDE(stext = .);
            KEEP(*(.isr_vector))
            KEEP(*(.init))
            *(.text .text.*)        
            *(.rodata .rodata.*)        
            *(.gnu.linkonce.t.*)
            *(.glue_7)
            *(.glue_7t)
            *(.gcc_except_table)
            *(.gnu.linkonce.r.*)
            . = ALIGN(4);
            _etext = .;
    		_sidata = _etext;
            PROVIDE(etext = .);   
         		_fini = . ;
    				*(.fini)
    
        } &gt;flash

What does KEEP mean in a linker script?

Some platforms mandate that you provide a list of a shared library&#39;s external symbols to the linker. However, on most unixish systems that&#39;s not necessary: all non-static symbols will be available by default.

My understanding is that the GNU toolchain can optionally restrict visibility just to symbols explicitly declared. How can that be achieved using GNU ld?

All Linker Scripts Solutions on Gang of Coders

Total of 3 Linker Scripts Solutions

How to get the size of an input section (to place it at the end of memory)

What does KEEP mean in a linker script?

Limiting visibility of symbols when linking shared libraries