Da ich das gleiche Bedürfnis hatte, alle geladenen Symbolnamen zur Laufzeit abzurufen, habe ich basierend auf der Antwort von R.. einige Nachforschungen angestellt. Hier ist also eine detaillierte Lösung für gemeinsam genutzte Linux-Bibliotheken im ELF-Format, die mit meinem gcc 4.3.4 funktioniert, aber hoffentlich auch mit neueren Versionen.
Ich habe hauptsächlich die folgenden Quellen verwendet, um diese Lösung zu entwickeln:
- ELF-Manpage
- Beispielcode (gefunden bei der Suche nach "dl_iterate_phdr")
Und hier ist mein Code. Ich habe selbsterklärende Variablennamen verwendet und detaillierte Kommentare hinzugefügt, um es verständlich zu machen. Wenn etwas falsch ist oder fehlt, lassen Sie es mich bitte wissen ... (Bearbeiten:Ich habe gerade festgestellt, dass die Frage für C war und mein Code für C ++. Aber wenn Sie den Vektor und die Zeichenfolge weglassen, sollte es auch für C funktionieren )
#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;
}
Auf dynamisch verknüpften ELF-basierten Systemen haben Sie möglicherweise eine Funktion dl_iterate_phdr verfügbar. Wenn dies der Fall ist, kann es verwendet werden, um Informationen zu jeder geladenen gemeinsam genutzten Bibliotheksdatei zu sammeln, und die Informationen, die Sie erhalten, reichen aus, um die Symboltabellen zu untersuchen. Der Prozess ist im Wesentlichen:
- Erhalte die Adresse der Programmkopfzeilen aus
dl_phdr_infoStruktur an Sie zurückgereicht. - Verwenden Sie den
PT_DYNAMICProgrammkopf, um den_DYNAMICzu finden Tabelle für das Modul. - Verwenden Sie den
DT_SYMTAB,DT_STRTAB, undDT_HASHEinträge von_DYNAMICum die Liste der Symbole zu finden.DT_HASHwird nur benötigt, um die Länge der Symboltabelle zu erhalten, da sie anscheinend nirgendwo anders gespeichert ist.
Die Typen, die Sie brauchen, sollten alle in <elf.h> sein und <link.h> .
Dies ist nicht wirklich C-spezifisch, sondern Betriebssystem- und Binärformat und (zum Debuggen von Symbolen und unverfälschten C++-Symbolnamen) sogar Compiler-spezifische Frage. Es gibt keinen generischen Weg und auch keinen wirklich eleganten Weg.
Der portabelste und zukunftssicherste Weg ist wahrscheinlich das Ausführen eines externen Programms wie nm , die sich in POSIX befindet. Die GNU-Version, die in Linuxen zu finden ist, hat wahrscheinlich eine Reihe von Erweiterungen, die Sie vermeiden sollten, wenn Sie auf Portabilität und Zukunftssicherheit abzielen.
Seine Ausgabe sollte stabil bleiben, und selbst wenn sich Binärformate ändern, wird es auch aktualisiert und funktioniert weiter. Führen Sie es einfach mit den richtigen Schaltern aus, erfassen Sie seine Ausgabe (wahrscheinlich, indem Sie es durch popen laufen lassen um eine temporäre Datei zu vermeiden) und analysieren Sie diese.