I don't really have a codebase for this board. I create a project in CubeMX, configure the peripherals and clock, and generate the code. All the small gaps in there must be filled later. Let's have a look at the CubeMX part first, followed by the gcc flags.

CubeMX

My computer is running Ubuntu 14.04. CubeMX is written for windows, but I didn't have any problems yet. The installer is an archive, and can be executed with java:

java -jar SetupSTM32CubeMX-4.6.0.exe

You might need root permissions for installing, but not for executing the software later. Install where you like, I installed it somewhere in my home directory.

To run:

java -jar ~/path/to/CubeMX/installation/STM32CubeMX.exe

this is also in my bash aliases.

Warning: CubeMX 4.5.0 had path problems ("/" vs "\"), 4.6.0 seems to behave better in this respect.

Now that CubeMX is running, we can configure our chip, clocks, peripherals. Code generation is the next crucial step. Here are my project settings:

• project tab:
  • Toolchain/IDE: TrueSTUDIO 4.3.1
    
• code generator tab:
  
  • Copy all used libraries into the project folder
  • Generate peripheral initialization as a pair of '.c/.h' files per IP
  • Keep user code when re-generating
  • Delete previously generated files when not re-generated

A note about "keep user code": This apparently doesn't include the linker script. CubeMX will, however, generate an empty linker script for the STM32F030F4P6. Once I filled it with content, it got erased after I re-generated the project. So if you write a linker script, store it in a place where CubeMX will not touch it.

gcc

• Compiler:
  

  -Wall
  -mlittle-endian
  -mthumb
  -Os
  -mcpu=cortex-m0
  -ffunction-sections
  -fdata-sections
  -fno-exceptions
  -flto
  -DSTM32F030x6

  The last define might be a bit surprising, but it's actually the correct one for this subfamily.
• Linker:
  

  -TSTM32F030F4_FLASH.ld
  -mcpu=cortex-m0
  -mthumb
  -Wl,--gc-sections
  --specs=nano.specs
  --specs=nosys.specs
  -Os
  -flto
  -lc_nano
  -lnosys

The linker script might be of interest:

ENTRY(Reset_Handler)

/* Highest address of the user mode stack */
_estack = 0x20000FFF;    /* end of RAM */

/* Generate a link error if heap and stack don't fit into RAM */
_Min_Heap_Size = 0x200;      /* required amount of heap  */
_Min_Stack_Size = 0x400; /* required amount of stack */

/* Specify the memory areas */
MEMORY
{
FLASH (rx)      : ORIGIN = 0x8000000, LENGTH = 16K
RAM (xrw)      : ORIGIN = 0x20000000, LENGTH = 4K
}

/* Define output sections */
SECTIONS
{
  /* The startup code goes first into FLASH */
  .isr_vector :
  {
    . = ALIGN(4);
    KEEP(*(.isr_vector)) /* Startup code */
    . = ALIGN(4);
  } >FLASH

  /* The program code and other data goes into FLASH */
  .text :
  {
    . = ALIGN(4);
    *(.text)           /* .text sections (code) */
    *(.text*)          /* .text* sections (code) */
    *(.glue_7)         /* glue arm to thumb code */
    *(.glue_7t)        /* glue thumb to arm code */
    *(.eh_frame)

    KEEP (*(.init))
    KEEP (*(.fini))

    . = ALIGN(4);
    _etext = .;        /* define a global symbols at end of code */
  } >FLASH

  /* Constant data goes into FLASH */
  .rodata :
  {
    . = ALIGN(4);
    *(.rodata)         /* .rodata sections (constants, strings, etc.) */
    *(.rodata*)        /* .rodata* sections (constants, strings, etc.) */
    . = ALIGN(4);
  } >FLASH

  .ARM.extab   : { *(.ARM.extab* .gnu.linkonce.armextab.*) } >FLASH
  .ARM : {
    __exidx_start = .;
    *(.ARM.exidx*)
    __exidx_end = .;
  } >FLASH

  .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(.init_array.*)))
    KEEP (*(.init_array*))
    PROVIDE_HIDDEN (__init_array_end = .);
  } >FLASH
  .fini_array :
  {
    PROVIDE_HIDDEN (__fini_array_start = .);
    KEEP (*(SORT(.fini_array.*)))
    KEEP (*(.fini_array*))
    PROVIDE_HIDDEN (__fini_array_end = .);
  } >FLASH

  /* used by the startup to initialize data */
  _sidata = LOADADDR(.data);

  /* Initialized data sections goes into RAM, load LMA copy after code */
  .data :
  {
    . = ALIGN(4);
    _sdata = .;        /* create a global symbol at data start */
    *(.data)           /* .data sections */
    *(.data*)          /* .data* sections */

    . = ALIGN(4);
    _edata = .;        /* define a global symbol at data end */
  } >RAM AT> FLASH


  /* Uninitialized data section */
  . = ALIGN(4);
  .bss :
  {
    /* This is used by the startup in order to initialize the .bss secion */
    _sbss = .;         /* define a global symbol at bss start */
    __bss_start__ = _sbss;
    *(.bss)
    *(.bss*)
    *(COMMON)

    . = ALIGN(4);
    _ebss = .;         /* define a global symbol at bss end */
    __bss_end__ = _ebss;
  } >RAM

  /* User_heap_stack section, used to check that there is enough RAM left */
  ._user_heap_stack :
  {
    . = ALIGN(4);
    PROVIDE ( end = . );
    PROVIDE ( _end = . );
    . = . + _Min_Heap_Size;
    . = . + _Min_Stack_Size;
    . = ALIGN(4);
  } >RAM
}

I actually took a linker script from the CubeMX repo that was written for a bigger chip and I simply adjust flash and ram size. I'm not sure if this is correct!