phoenix_dl.h File Reference

#include <string>
#include <vector>

Include dependency graph for phoenix_dl.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	phoenix_listLibrarySymbol (std::vector< std::string > &vecFunction, const std::string &libFileName)
	List the symbols in the given library.
std::string	phoenix_mangleFunction (const std::string &functionPrototype, const std::string &extraInclude="", const std::string &compiler="g++")
	Mangle the given function prototype.

Function Documentation

phoenix_listLibrarySymbol()

void phoenix_listLibrarySymbol	(	std::vector< std::string > &	vecFunction,
		const std::string &	libFileName )

List the symbols in the given library.

Parameters

[out]	vecFunction	: vector of function names in the given library
	libFileName	: name of the library to be loaded

Definition at line 23 of file phoenix_dl.cpp.

                                                                                                 {
        if(libFileName == ""){return;}
        void* library = dlopen(libFileName.c_str(), RTLD_LAZY | RTLD_GLOBAL);
        if(library == NULL){
                std::cerr << "phoenix_listLibrarySymbol : library '"<<libFileName<<"' not found" << std::endl;
                return;
        }
        struct link_map * map = NULL;
        dlinfo(library, RTLD_DI_LINKMAP, &map);
 
        Elf64_Sym * symtab = nullptr;
        char * strtab = nullptr;
        int symentries = 0;
        for(auto section = map->l_ld; section->d_tag != DT_NULL; ++section){
                if(section->d_tag == DT_SYMTAB){
                        symtab = (Elf64_Sym *)section->d_un.d_ptr;
                }
                if(section->d_tag == DT_STRTAB){
                        strtab = (char*)section->d_un.d_ptr;
                }
                if(section->d_tag == DT_SYMENT){
                        symentries = section->d_un.d_val;
                }
        }
        int size = strtab - (char *)symtab;
        for(int k = 0; k < size / symentries; ++k){
                auto sym = &symtab[k];
                // If sym is function
                if(ELF64_ST_TYPE(symtab[k].st_info) == STT_FUNC){
                        //str is name of each symbol
                        auto str = &strtab[sym->st_name];
                        vecFunction.push_back(std::string(str));
//                      printf("%s\n", str);
                }
        }
        dlclose(library);
}

phoenix_mangleFunction()

std::string phoenix_mangleFunction	(	const std::string &	functionPrototype,
		const std::string &	extraInclude,
		const std::string &	compiler )

Mangle the given function prototype.

Parameters

functionPrototype	: prototype of the function to be mangled
extraInclude	: extra include to be used to get the mangled function
compiler	: compiler to be used

Returns

corresponding mangled function name

Definition at line 67 of file phoenix_dl.cpp.

                                                                                                                                 {
        std::string command("echo \"#include <new>\\n#include <string>\\n"+extraInclude+"\\n"+functionPrototype+" {} \" | "+compiler+" -x c++ -S - -o- | grep \"@function\" | cut -d ',' -f 1 | sed -e \"s/.type//g\" | sed -s \"s/ //g\" | sed -e \"s/\t//g\"");
        FILE * fp = popen(command.c_str(), "r");
        if(fp == NULL){
                std::cerr << "phoenix_mangleFunction : cannot get result of command '"<<command<<"'" << std::endl;
                return "";
        }
        std::string mangledFunction("");
        int buffer;
        while(!feof(fp)){
                buffer = fgetc(fp);
                if(buffer != EOF){
                        char ch = (char)buffer;
                        if(ch != ' ' && ch != '\t' && ch != '\n'){
                                mangledFunction += ch;
                        }
                }
                else break;
        }
        pclose(fp);
        return mangledFunction;
}