Posted by MSchultz on 2017-06-15 02:43

Before I go on to give advice here, let me state for the record that i’ve never tried to do with an ARM core device and GCC what you’re describing here, but I’m familiar in a general sense with the concept of placing a section of code that is “loaded” in ROM/FLASH and then copied/relocated to RAM, and have done this with different toolchains and MCUs other than the STM32.

I think you have the linker script syntax correct - in particular, the bit at the end of the .itcm_text section declaration (>ITCM_RAM AT >FLASH) is critical. You want to make sure that your itcm-destined code is loaded into ROM (flash), but is located in ITCM_RAM.

I think what you’re looking for is the appropriate attribute syntax that you add to all functions that you want placed in a non-standard section. Here’s what it would look like:

int foo(int bar) __attribute__((section(".itcm_text")))
{
    // Code
}

You’ll need to add the attribute directive shown in the example above to each function or variable declaration that you want to have placed in the .itcm_text section.

You might want to modify your linker command file to add some symbol definitions that will make it easier for your code to find (and copy) the .itcm_text section to ITCM_RAM

.itcm_text :
{
. = ALIGN(4);
itcm_text_start = .;
*(.itcm_text) /* Fast-executing code */
*(.itcm_text*) /* Fast-executing code */
. = ALIGN(4);
itcm_text_end = .;
} >ITCM_RAM AT >FLASH

When it comes time to copy the ITCM code in ROM to ITCM_RAM, you should be able to do something like this:

// The "variables" referenced here don't actually contain anything meaningful - they are defined as symbols
// within the linker script. To extract the value assigned to each of these symbols, you need to take the
// address-of them (use the & address-of operator); e.g.:
// unsigned int section_start = (unsigned int) &itcm_text_start;

extern const unsigned char itcm_text_start;	// Make these uint8_t/char so they are treated as byte pointers when address-of'ed
extern const unsigned char itcm_text_end;

unsigned int itcm_text_size = (unsigned int) (&itcm_text_end - &itcm_text_start); // Pointer math should will work if these are declared as a char/byte type
unsigned char *itcm_ram_addr = ??? // Fill this in - could also get it from linker symbol if you add one
memcpy(itcm_ram_addr, &itcm_text_start, itcm_text_size);

Caveat: I’ve written the above “off the cuff” after doing a little research - I’ve not actually tried or tested any of it. I’ve probably got one or more of the details wrong. I may need to do something like this in one of my own projects I’ll be working on soon so I figured I’d start to research it now and possibly answer laltmann’s question at the same time.

Posted by dautrevaux on 2017-06-15 14:06

Hi,

There is a typo in the original post: the attribute used for placing functions in ITCM must be attribute((.itcm_text)), not .itcm_ram. This may explain why the .itcm_text section is empty...

Bernard (Ac6)

Posted by laltmann on 2017-06-16 02:09

Thanks MSchultz and dautrevaux. I had indeed made a typo - corrected that now, and my test function does now show up in the .itcm_text section of my output.map file. With a few more changes to the linker script I was able to get my function successfully moved into ITCM RAM and verified with the debugger that it was running from that location.

I changed my memory sections definition a bit as well to make sure that the code doesn’t clobber the ISR vector table, which is loaded into the start of ITCM RAM by the startup script. I allocated 1kB for that table and started my section after:

/* Specify the memory areas */
MEMORY
{
ITCM_ISR (rx) : ORIGIN = 0x00000000, LENGTH = 1K
ITCM_RAM (rx) : ORIGIN = 0x00000400, LENGTH = 15K
RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 320K
FLASH (rx) : ORIGIN = 0x00200000, LENGTH = 1024K
}

I also added the symbol definitions as suggested so that I can memcpy the right section into that portion of memory later on. But it took an additional symbol in order to actually find the function data in Flash, to know where to copy from.

I based this on how the .data section is handled. There’s an extra symbol before that section is defined:

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

That gets picked up by the startup script to know where to load initialization data from to populate the .data section of ram. So my linker script ends up looking like:

/* Copy specific fast-executing code to ITCM RAM */
itcm_data = LOADADDR(.itcm_text);
.itcm_text :
{
. = ALIGN(4);
itcm_text_start = .;
*(.itcm_text)
*(.itcm_text*)
. = ALIGN(4);
itcm_text_end = .;
} >ITCM_RAM AT> FLASH

Then at the start of main() I have the following:

/* Load functions into ITCM RAM */
extern const unsigned char itcm_text_start;
extern const unsigned char itcm_text_end;
extern const unsigned char itcm_data;
memcpy(&itcm_text_start, &itcm_data, (int) (&itcm_text_end - &itcm_text_start));

And with that I’m good to go! Thanks again for the help.