Allocare una funzione in C in un preciso indirizzo di memoria del processore

[mrcz]

Ciao a tutti.
Vorrei far allocare alcune funzioni all'interno del processore (ARM7) di un dispositivo all'indirizzo che desidero.

Allora, mi sono creato nel file .ind, che rappresenta la "forma" della flash interna del micro, alcune sezioni:

e.g:

__PROG_DATA__ = 0x00018050;

.progdata __PROG_DATA__ :
{
*(.progdata)
}

Adesso esiste una sezione .progdata che parte dall'indirizzo 0x00018050 (hex) del micro e tutte le funzioni che nella propria dichiarazione contengono l'attributo

__attribute__ ((section (".progdata")));

vengono allocate a partire dall'idirizzo 0x00018050

e.g:
void My_func(void) __attribute__ ((section (".progdata")));

Come posso fare, nel caso avessi più funzioni e mi interessasse allocarle all'interno della sezione .progdata, ad allocarle prorpio in un punto preciso della medesima sezione?

Con un esempio, ci sono:

void My_func1(void) __attribute__ ((section (".progdata")));
void My_func2(void) __attribute__ ((section (".progdata")));
void My_func3(void) __attribute__ ((section (".progdata")));

supponiamo che siano grosse 0x50 (hex) e se andassi a vedere nel file .map vedrei all'indirizzo 0x00018050 allocata la funzione My_func1, all'indirizzo 0x00018100 la My_func2 e all'indirizzo 0x00018150 la My_func3.
Ma è stato il linker a decidere questa disposizione e poteva interscambiare le Myfunc di posizione tipo prima la 3 poi la 1 e infine la 2 e comunque tutte e tre sempre contigue in memoria.

Quindi come faccio a dire che ad esempio voglio che la funzione My_func3 venga allocata in 0x00018300 anzichè dove me la mette il linker cioè all'indirizzo 0x00018150?

Ringrazio tutti anticipatamente.

Marco

[linoma]

Queste direttive di cui parli nn fanno altro che inserire del codice, del tutto trasparente, che viene solitamente eseguito durante l'avvio, che nn fa altro che copiare il tuo codice all'indirizzo specifito dal linker. Una soluzione potrebbe essere quella di copiare tu manulamente il tuo codice nelle zone di memoria che vuoi. Ma attendo il tuo codice deve essere assolutamente relativo.
Xche ti serve questa cosa? Forse potrebbero esserci altre soluzioni.

[mrcz]

Ciao linoma grazie per la risposta.
Bella domanda...ma un po incasinata da spiegare.

Sto cercando di inserire due firmware parzialmente diversi su un unico micro.
I due hanno in comune la parte in assembler per lo startup, la tabella degli interrupt e i driver SPI (mi servono per l'accesso ad una flash esterna in fase di inizializzazione periferiche)
Per in comune intendo che in tutti e due i fw (ognuno dei qualli ha il suo .ind) i componenti (codice) sono presenti in entrambi, quindi vengono praticamente riscritti dall'ultimo fw che viene caricato (con un jtag) ma il primo fw caricato se li ritroverà nello stesso posto dove crede che siano (anche se ribadisco sono stati riscritti).

Il primo deve rimanere in pianta stabile sul micro e non deve essere mai toccato, il secondo invece deve poter essere riscritto dal primo (in fase di accensione ovvero prima che il primo faccia il salto al main del secondo e subito dopo le inizializzazioni delle periferiche che mi servono)

Tutto questo viene fatto in modo da creare un "flasher" che mi caricherà il secondo firmware quando all'accensione ne troverà uno in flash esterna diverso da quello che è scritto in flash interna del micro.

Mi serve che le funzioni comuni dell' SPI siano allocate precisamente ad un certo indirizzo e che il linker per ogni fw le linki proprio lì, altrimenti si incricca tutto (ho già fatto molti test e mi è capitato che il secondo fw si aspettasse che una funz fosse in un certo indirizzo mentre invece non era li. La sezione era corretta per via dell' __attribute__ di cui sopra ma non l'indirizzo nella sezione).

Mi servirebbe capire come organizzare le funzioni all'interno di una sezione.

Cosa intendi per "copiare tu manulamente il tuo codice nelle zone di memoria che vuoi"?

Mi posti un esempio?

Grazie linoma.

[linoma]

Quello che dico si riduce ad un semplice memcpy(dst,src,size). Ma è l'organizzazione del codice che è la parte + complicata. Infatti ecco il motivo per il quale ti chiedevo cosa fosse la tua applicazione, xche io troverei una soluzione + vicino all'applicazione e nn creare qualcosa di generale cm ho postato prima.
Sia xche richiede delle conoscenze dei tools e del hardware che si usano e sia xche è molto complesso si parla di linkare dinamicamente del codice a runtime, conosciutissimo cn il nome di DLL.
X la compilazione credo che tu usi qualcosa tipo il GCC, ecco cn il GCC basta indicare tra le varie opzioni -fPIC ed il compilatore genera del codice rilocabile (relativo cm dicevo prima).
Ma poi ce il grosso, e cioe caricarlo in memoria (basta un memcpy) ed aggiustare i vari indirizzi. Ecco, se riesci a trovare qualcosa su internet, oppure qualcuno che ha gia qualcosa, fai molto prima anche xche scrivere qualcosa qui mi farebbe bannare vista la mole di cs che sarei costretto a postare ed anche xche mi stancherei troppo .
Molto probabilmente, se utilizzi delle schede embedded sicuramente ce anche del codice gia pronto altrimenti ripeto, almeno che nn ci sia qualche opzione nei tools che possiedi, scirvere qualcosa + appropriato alla tua applicazione, anche al costo di avere doppio codice, x me è la soluzione migliore.