How to convert MyLibName.a to MyLibName.bin?

I should add details!

1) MCU - STM32H7

2) IDE - STM32CubeIDE

If I need to add something else about this topic just tell me!

Kind of a LINKER task, or a LOADER one.

You'd either need to make a shell application, with a large table of function entry points, making the linker build that into a binary, and perhaps have a means to register entry points into RAM allocation in your hosting application.

Alternatively you stay with ELF objects, and load and bind those from your host side loader. In a EXE / DLL, or shared object model.

I don't think the ELF object is overly complex, but one could also make a simplified or condensed object format more suited to specific needs. I might strip excessive debug and internal symbol noise all the same.

Historically you pass "definition" files to linkers to associate code in binary blobs. Might be simpler to have a structure you share, with function pointers.

>> Might be simpler to have a structure you share, with function pointers.

I fully agree with you, it would not be a bad solution, but I also need to link touchGFX in this way. For the touchGFX, therefore, it may be a difficult solution.

I am very tired. Tomorrow I will continue to think about this.

But I like your idea - it is simple and reliable for my library.

Hello everyone and @Community member​ !

Here is our solution for simple libraries. I hope it will be useful to someone ))

1) create an empty project in STM32CubeIDE

2) ignore the startup file

3) in the main.c create some lowlevelInit function for initializing the data and bss sections and initializing the system library. It must be called from the host application before using this library!

void lowlevelInit(void)
{
 /////////////////////////////////////
 /// Data section
 /////////////////////////////////////
 
 extern uint32_t _sidata;
 extern uint32_t _sdata;
 extern uint32_t _edata;
 volatile uint32_t* data_load = &_sidata;
 volatile uint32_t* data = &_sdata;
 volatile uint32_t* data_end = &_edata;
 while( data < data_end ) {
 *(data++) = *(data_load++);
 }
 
 /////////////////////////////////////
 /// BSS section
 /////////////////////////////////////
 
 extern unsigned _sbss ;
 extern unsigned _ebss ;
 unsigned *bss = &_sbss ;
 unsigned *bss_end = &_ebss ;
 while(bss < bss_end ) {
 *(bss++) = 0 ;
 }
 
 /////////////////////////////////////
 /// System library Initialization
 /////////////////////////////////////
 
 extern __attribute__ ((weak)) void __libc_init_array(void);
 if (__libc_init_array) {
 __libc_init_array();
 }
}

4) rename isr_vector section to api_vector in the linker file

/* Specify the memory areas */
MEMORY
{
 FLASH (rx) : ORIGIN = 0x08180000, LENGTH = 512K
 RAM_D1 (xrw) : ORIGIN = 0x24040000, LENGTH = 256K
}
 
/* Define output sections */
SECTIONS
{
 /* The startup code goes first into FLASH */
 .api_vector :
 {
 . = ALIGN(4);
 KEEP(*(.api_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

5) In the main.c declare an array of function pointers on the library’s API

__attribute__ ((section(".api_vector"),used))
void (* const vectors[])(void) = {
 (void (*const)(void))lowlevelInit,
 (void (*const)(void))ver,
 (void (*const)(void))foo,
 (void (*const)(void))bar,
};

6) as a result, we have function pointers in the MyLib.bin

To use these functions inside of the host application we use the following approach:

 #define LIBRARY_API_ADDRESS 0x08180000
 
 void (*init)(void) = (void(*)(void))(*(uint32_t volatile *)((uint32_t) LIBRARY_API_ADDRESS + 0));
 char* (*ver)(void) = (char*(*)(void))(*(uint32_t volatile *)((uint32_t) LIBRARY_API_ADDRESS + 4));
 int (*foo)(int a, int b, int c) = (int(*)(int, int, int))(*(uint32_t volatile *)((uint32_t) LIBRARY_API_ADDRESS + 8));
 int (*bar)(int a, int b) = (int(*)(int, int))(*(uint32_t volatile *)((uint32_t) LIBRARY_API_ADDRESS + 12));
 
 init();
 
 printf("version = %s\n", ver());
 printf("foo = %d\n", foo(1, 2, 3));
 printf("bar = %d\n", bar(6, 5));

So, as you can see, this method is not very good for TouchGFX.

Does anyone have any ideas on this issue?