c++ - compilar - ¿Lista todas las funciones/símbolos sobre la marcha en código C en una arquitectura Linux?

gcc compilador

Question

Supongamos que main.c utiliza símbolos de main.c compartidas y funciones locales declaradas en main.c

¿Existe una forma agradable y elegante de imprimir una lista de todos los nombres de funciones y símbolos disponibles en tiempo de ejecución?

Debería ser posible ya que los datos se cargan en el segmento .code .

Answer 1

Como tenía la misma necesidad de recuperar todos los nombres de símbolos cargados en el tiempo de ejecución, hice una investigación basada en la respuesta de R .. Así que aquí hay una solución detallada para las bibliotecas compartidas de Linux en formato ELF que funciona con mi gcc 4.3.4, pero con suerte también con las versiones más nuevas.

Usé principalmente las siguientes fuentes para desarrollar esta solución:

• Página de manual de ELF
• Algún código de ejemplo (lo encontré mientras buscaba "dl_iterate_phdr")

Y aquí está mi código. Utilicé nombres de variables autoexplicativos y añadí comentarios detallados para hacerlo comprensible. Si algo está mal o falta, hágamelo saber ... (Edición: Me di cuenta de que la pregunta era para C y mi código es para C ++. Pero si deja de lado el vector y la cadena, también debería funcionar para 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;
}

Answer 2

Debería ser dl_iterate_phdr(retrieve_symbolnames, &symbolNames);

Answer 3

En los sistemas basados ​​en ELF vinculados dinámicamente, puede tener una función dl_iterate_phdr disponible. Si es así, puede usarse para recopilar información sobre cada archivo de biblioteca compartida cargado, y la información que obtiene es suficiente para examinar las tablas de símbolos. El proceso es básicamente:

1. Obtenga la dirección de los encabezados del programa de la estructura dl_phdr_info que se le devuelve.
2. Use el PT_DYNAMIC programa PT_DYNAMIC para encontrar la tabla _DYNAMIC para el módulo.
3. Utilice las DT_SYMTAB , DT_STRTAB y DT_HASH de _DYNAMIC para encontrar la lista de símbolos. DT_HASH solo es necesario para obtener la longitud de la tabla de símbolos, ya que no parece estar almacenado en ningún otro lugar.

Los tipos que necesita deben estar todos en <elf.h> y <link.h> .

Answer 4

Esto no es realmente específico de C, pero el sistema operativo y el formato binario y (para los símbolos de depuración y los nombres de símbolos de C ++ no enredados) incluso la pregunta específica del compilador. No hay una forma genérica, y tampoco una forma verdaderamente elegante.

La forma más portátil y segura del futuro es probablemente ejecutar un programa externo como nm , que está en POSIX. La versión de GNU que se encuentra en las Linux probablemente tenga muchas extensiones, que debería evitar si apunta a la portabilidad y la prueba de futuro.

Su salida debería mantenerse estable, e incluso si los formatos binarios cambian, también se actualizará y seguirá funcionando. Simplemente ejecútelo con los interruptores correctos, capture su salida (probablemente ejecutándolo a través de popen para evitar un archivo temporal) y analícelo.