void char2lcd(char x) {volatile char tmp=x; }

void print(const char __generic *str)
{
  while(*str) char2lcd(*str++);
}

 __flash char str1[] = "FLASH string";
 char str2[] = "SRAM string";

int main()
{
  print(str1);
  print(str2);
}

 /*
     * Used for validation only, do not allocate anything here!
     *
     * This is just to check that there is enough RAM left for the Main
     * stack. It should generate an error if it's full.
     */
    ._check_stack : ALIGN(4)
    {
        . = . + _Minimum_Stack_Size ;
    } >RAM
   
    /*
     * The FLASH Bank1.
     * The C or assembly source must explicitly place the code
     * or data there using the "section" attribute.
     */
    .b1text : ALIGN(4)
    {
        *(.b1text)                   /* remaining code */
        *(.b1rodata)                 /* read-only data (constants) */
        *(.b1rodata.*)
    } >FLASHB1
   
    /*
     * The EXTMEM.
     * The C or assembly source must explicitly place the code or data there
     * using the "section" attribute.
     */

    /* EXTMEM Bank0 */
    .eb0text : ALIGN(4)
    {
        *(.eb0text)                   /* remaining code */
        *(.eb0rodata)                 /* read-only data (constants) */
        *(.eb0rodata.*)
    } >EXTMEMB0
   
    /* EXTMEM Bank1 */
    .eb1text : ALIGN(4)
    {
        *(.eb1text)                   /* remaining code */
        *(.eb1rodata)                 /* read-only data (constants) */
        *(.eb1rodata.*)
    } >EXTMEMB1
   
    /* EXTMEM Bank2 */
    .eb2text : ALIGN(4)
    {
        *(.eb2text)                   /* remaining code */
        *(.eb2rodata)                 /* read-only data (constants) */
        *(.eb2rodata.*)
    } >EXTMEMB2
   
    /* EXTMEM Bank0 */
    .eb3text : ALIGN(4)
    {
        *(.eb3text)                   /* remaining code */
        *(.eb3rodata)                 /* read-only data (constants) */
        *(.eb3rodata.*)
    } >EXTMEMB3

    .inits : ALIGN(4)
    {
        /*
         * Memory regions initialisation arrays.
         *
         * Thee are two kinds of arrays for each RAM region, one for
         * data and one for bss. Each is iterrated at startup and the   
         * region initialisation is performed.
         *
         * The data array includes:
         * - from (LOADADDR())
         * - region_begin (ADDR())
         * - region_end (ADDR()+SIZEOF())
         *
         * The bss array includes:
         * - region_begin (ADDR())
         * - region_end (ADDR()+SIZEOF())
         *
         * WARNING: It is mandatory that the regions are word aligned,
         * since the initialisation code works only on words.
         */
         
        __data_regions_array_start = .;
       
        LONG(LOADADDR(.data));
        LONG(ADDR(.data));
        LONG(ADDR(.data)+SIZEOF(.data));
       
        LONG(LOADADDR(.data_CCMRAM));
        LONG(ADDR(.data_CCMRAM));
        LONG(ADDR(.data_CCMRAM)+SIZEOF(.data_CCMRAM));
       
        __data_regions_array_end = .;
       
        __bss_regions_array_start = .;
       
        LONG(ADDR(.bss));
        LONG(ADDR(.bss)+SIZEOF(.bss));
       
        LONG(ADDR(.bss_CCMRAM));
        LONG(ADDR(.bss_CCMRAM)+SIZEOF(.bss_CCMRAM));
       
        __bss_regions_array_end = .;

        /* End of memory regions initialisation arrays. */
   
        /*
         * These are the old initialisation sections, intended to contain
         * naked code, with the prologue/epilogue added by crti.o/crtn.o
         * when linking with startup files. The standalone startup code
         * currently does not run these, better use the init arrays below.
         */
      KEEP(*(.init))
      KEEP(*(.fini))

      . = ALIGN(4);

      /*
         * The preinit code, i.e. an array of pointers to initialisation
         * functions to be performed before constructors.
         */
      PROVIDE_HIDDEN (__preinit_array_start = .);
       
        /*
         * Used to run the SystemInit() before anything else.
         */
      KEEP(*(.preinit_array_sysinit .preinit_array_sysinit.*))
       
        /*
         * Used for other platform inits.
         */
      KEEP(*(.preinit_array_platform .preinit_array_platform.*))
       
        /*
         * The application inits. If you need to enforce some order in
         * execution, create new sections, as before.
         */
      KEEP(*(.preinit_array .preinit_array.*))

      PROVIDE_HIDDEN (__preinit_array_end = .);

      . = ALIGN(4);

      /*
         * The init code, i.e. an array of pointers to static constructors.
         */
      PROVIDE_HIDDEN (__init_array_start = .);
      KEEP(*(SORT(.init_array.*)))
      KEEP(*(.init_array))
      PROVIDE_HIDDEN (__init_array_end = .);

      . = ALIGN(4);

      /*
         * The fini code, i.e. an array of pointers to static destructors.
         */
      PROVIDE_HIDDEN (__fini_array_start = .);
      KEEP(*(SORT(.fini_array.*)))
      KEEP(*(.fini_array))
      PROVIDE_HIDDEN (__fini_array_end = .);

    } >FLASH

    /* The secondary uninitialised data section. */
   .bss_CCMRAM (NOLOAD) : ALIGN(4)
   {
      *(.bss.CCMRAM .bss.CCMRAM.*)
   } > CCMRAM

    .noinit_CCMRAM (NOLOAD) : ALIGN(4)
    {
        *(.noinit.CCMRAM .noinit.CCMRAM.*)         
    } > CCMRAM

   .preinit_array :
   {   PROVIDE(__preinit_array_start = .);
      KEEP(*(.preinit_array*))
      PROVIDE(__preinit_array_end = .);
   } > FLASH

   .init_array :
   {   PROVIDE(__init_array_start = .);
      KEEP(*(SORT(.init_array.*)))
      KEEP(*(.init_array*))
      PROVIDE(__init_array_end = .);
   } > FLASH

   .fini_array :
   {   PROVIDE(__fini_array_start = .);
      KEEP(*(.fini_array*))
      KEEP(*(SORT(.fini_array.*)))
      PROVIDE(__fini_array_end = .);
   } > FLASH

   .reserved_for_stack (NOLOAD) :
   {   . = ALIGN(4);
      PROVIDE(__reserved_for_stack_start__ = .);
      KEEP(*(.reserved_for_stack))
      . = ALIGN(4);
      PROVIDE(__reserved_for_stack_end__ = .);
   } > SRAM

MEMORY
{
    FLASH     (rx)  : ORIGIN = 0x00000000, LENGTH = 256k
    RAM     (xrw)   : ORIGIN = 0x20000000, LENGTH = 64k
}

GROUP(
   libgcc.a
   libg.a
   libc.a
   libm.a
   libnosys.a
 )

__stack = ORIGIN(RAM) + LENGTH(RAM);

SECTIONS
{
    . = ORIGIN(FLASH);
 
    .isr_vectors : ALIGN(4)
    {
        FILL(0xFF)
        __vectors_start__ = ABSOLUTE(.);
        KEEP(*(.vectors))
        *(.after_vectors .after_vectors.*)
    } > FLASH

    /*
     * Start of text.
     */
    _text = .;

    .text : ALIGN(4)
    {
        *(.text)
        *(.text.*)
        *(.glue_7t)
        *(.glue_7)
        *(.gcc*)
    } > FLASH

    /*
     * Arm section unwinding.
     * If removed may cause random crashes.
     */
    .ARM.extab :
    {
        *(.ARM.extab* .gnu.linkonce.armextab.*)
    } > FLASH

    /*
     * Arm stack unwinding.
     * If removed may cause random crashes.
     */
    .ARM.exidx :
    {
        __exidx_start = .;
        *(.ARM.exidx* .gnu.linkonce.armexidx.*)
        __exidx_end = .;
    } > FLASH

    /*
     * Read-only data. Consts should also be here.
     */
    .rodata : ALIGN(4)
    {
        . = ALIGN(4);
        __rodata_start__ = .;
        *(.rodata)
        *(.rodata.*)
        . = ALIGN(4);
        __rodata_end__ = .;
    } > FLASH

    /*
     * End of text.
     */
    _etext = .;

    /*
     * Data section.
     */
    .data : ALIGN(4)
    {
        FILL(0xFF)
        . = ALIGN(4);
        PROVIDE(__textdata__ = LOADADDR(.data));
        PROVIDE(__data_start__ = .);
        *(.data)
        *(.data.*)
        *(.ramtext)
        . = ALIGN(4);
        PROVIDE(__data_end__ = .);
    } > RAM AT > FLASH

    /*
     * BSS section.
     */
    .bss (NOLOAD) : ALIGN(4)
    {
        . = ALIGN(4);
        PROVIDE(_bss_start = .);
        __bss_start__ = .;
        *(.bss)
        *(.bss.*)
        *(COMMON)
        . = ALIGN(4);
        PROVIDE(_bss_end = .);
        __bss_end__ = .;
        PROVIDE(end = .);
    } > RAM

      .noinit (NOLOAD) : ALIGN(4)
    {
        __noinit_start__ = .;
        *(.noinit .noinit.*)
         . = ALIGN(4) ;
        __noinit_end__ = .;   
    } > RAM
  }