Poiché avevo la stessa necessità di recuperare tutti i nomi dei simboli caricati in fase di esecuzione, ho svolto alcune ricerche basate sulla risposta di R.. Quindi ecco una soluzione dettagliata per le librerie condivise Linux in formato ELF che funziona con il mio gcc 4.3.4, ma si spera anche con le versioni più recenti.
Ho utilizzato principalmente le seguenti fonti per sviluppare questa soluzione:
- Manpage ELF
- Alcuni codici di esempio (trovati durante la ricerca di "dl_iterate_phdr")
Ed ecco il mio codice. Ho usato nomi di variabili autoesplicativi e ho aggiunto commenti dettagliati per renderlo comprensibile. Se qualcosa non va o manca, per favore fatemelo sapere... (Modifica:ho appena realizzato che la domanda era per C e il mio codice è per C++. Ma se tralasci il vettore e la stringa dovrebbe funzionare anche per C )
#include <link.h>
#include <string>
#include <vector>
using namespace std;
/* Callback for dl_iterate_phdr.
* Is called by dl_iterate_phdr for every loaded shared lib until something
* else than 0 is returned by one call of this function.
*/
int retrieve_symbolnames(struct dl_phdr_info* info, size_t info_size, void* symbol_names_vector)
{
/* ElfW is a macro that creates proper typenames for the used system architecture
* (e.g. on a 32 bit system, ElfW(Dyn*) becomes "Elf32_Dyn*") */
ElfW(Dyn*) dyn;
ElfW(Sym*) sym;
ElfW(Word*) hash;
char* strtab = 0;
char* sym_name = 0;
ElfW(Word) sym_cnt = 0;
/* the void pointer (3rd argument) should be a pointer to a vector<string>
* in this example -> cast it to make it usable */
vector<string>* symbol_names = reinterpret_cast<vector<string>*>(symbol_names_vector);
/* Iterate over all headers of the current shared lib
* (first call is for the executable itself) */
for (size_t header_index = 0; header_index < info->dlpi_phnum; header_index++)
{
/* Further processing is only needed if the dynamic section is reached */
if (info->dlpi_phdr[header_index].p_type == PT_DYNAMIC)
{
/* Get a pointer to the first entry of the dynamic section.
* It's address is the shared lib's address + the virtual address */
dyn = (ElfW(Dyn)*)(info->dlpi_addr + info->dlpi_phdr[header_index].p_vaddr);
/* Iterate over all entries of the dynamic section until the
* end of the symbol table is reached. This is indicated by
* an entry with d_tag == DT_NULL.
*
* Only the following entries need to be processed to find the
* symbol names:
* - DT_HASH -> second word of the hash is the number of symbols
* - DT_STRTAB -> pointer to the beginning of a string table that
* contains the symbol names
* - DT_SYMTAB -> pointer to the beginning of the symbols table
*/
while(dyn->d_tag != DT_NULL)
{
if (dyn->d_tag == DT_HASH)
{
/* Get a pointer to the hash */
hash = (ElfW(Word*))dyn->d_un.d_ptr;
/* The 2nd word is the number of symbols */
sym_cnt = hash[1];
}
else if (dyn->d_tag == DT_STRTAB)
{
/* Get the pointer to the string table */
strtab = (char*)dyn->d_un.d_ptr;
}
else if (dyn->d_tag == DT_SYMTAB)
{
/* Get the pointer to the first entry of the symbol table */
sym = (ElfW(Sym*))dyn->d_un.d_ptr;
/* Iterate over the symbol table */
for (ElfW(Word) sym_index = 0; sym_index < sym_cnt; sym_index++)
{
/* get the name of the i-th symbol.
* This is located at the address of st_name
* relative to the beginning of the string table. */
sym_name = &strtab[sym[sym_index].st_name];
symbol_names->push_back(string(sym_name));
}
}
/* move pointer to the next entry */
dyn++;
}
}
}
/* Returning something != 0 stops further iterations,
* since only the first entry, which is the executable itself, is needed
* 1 is returned after processing the first entry.
*
* If the symbols of all loaded dynamic libs shall be found,
* the return value has to be changed to 0.
*/
return 1;
}
int main()
{
vector<string> symbolNames;
dl_iterate_phdr(retrieve_symbolnames, &symbolNames);
return 0;
}
Sui sistemi basati su ELF a collegamento dinamico, potresti avere una funzione dl_iterate_phdr a disposizione. In tal caso, può essere utilizzato per raccogliere informazioni su ciascun file di libreria condivisa caricato e le informazioni ottenute sono sufficienti per esaminare le tabelle dei simboli. Il processo è fondamentalmente:
- Prendi l'indirizzo delle intestazioni del programma dal
dl_phdr_infostruttura che ti è stata restituita. - Usa il
PT_DYNAMICintestazione del programma per trovare il_DYNAMICtabella per il modulo. - Usa il
DT_SYMTAB,DT_STRTABeDT_HASHvoci di_DYNAMICper trovare l'elenco dei simboli.DT_HASHè necessario solo per ottenere la lunghezza della tabella dei simboli, dal momento che non sembra essere memorizzata da nessun'altra parte.
I tipi di cui hai bisogno dovrebbero essere tutti in <elf.h> e <link.h> .
Questo non è realmente specifico del C, ma del sistema operativo e del formato binario e (per il debug di simboli e nomi di simboli C++ non alterati) anche una domanda specifica del compilatore. Non esiste un modo generico e neppure un modo veramente elegante.
Il modo più portabile ea prova di futuro è probabilmente l'esecuzione di un programma esterno come nm , che si trova in POSIX. La versione GNU trovata in Linux ha probabilmente un sacco di estensioni, che dovresti evitare se miri alla portabilità e alla prova del futuro.
Il suo output dovrebbe rimanere stabile e, anche se i formati binari cambiano, verrà aggiornato e continuerà a funzionare. Basta eseguirlo con le opzioni giuste, catturarne l'output (probabilmente eseguendolo attraverso popen per evitare un file temporaneo) e analizzarlo.