No manual entry for -- in section 3 dladdr(3) Library Functions Manual dladdr(3) NAME dladdr, dladdr1 - translate address to symbolic information LIBRARY Dynamic linking library (libdl, -ldl) SYNOPSIS #define _GNU_SOURCE #include <dlfcn.h> int dladdr(const void *addr, Dl_info *info); int dladdr1(const void *addr, Dl_info *info, void **extra_info, int flags); DESCRIPTION The function dladdr() determines whether the address specified in addr is located in one of the shared objects loaded by the calling applica- tion. If it is, then dladdr() returns information about the shared ob- ject and symbol that overlaps addr. This information is returned in a Dl_info structure: typedef struct { const char *dli_fname; /* Pathname of shared object that contains address */ void *dli_fbase; /* Base address at which shared object is loaded */ const char *dli_sname; /* Name of symbol whose definition overlaps addr */ void *dli_saddr; /* Exact address of symbol named in dli_sname */ } Dl_info; If no symbol matching addr could be found, then dli_sname and dli_saddr are set to NULL. The function dladdr1() is like dladdr(), but returns additional informa- tion via the argument extra_info. The information returned depends on the value specified in flags, which can have one of the following val- ues: RTLD_DL_LINKMAP Obtain a pointer to the link map for the matched file. The ex- tra_info argument points to a pointer to a link_map structure (i.e., struct link_map **), defined in <link.h> as: struct link_map { ElfW(Addr) l_addr; /* Difference between the address in the ELF file and the address in memory */ char *l_name; /* Absolute pathname where object was found */ ElfW(Dyn) *l_ld; /* Dynamic section of the shared object */ struct link_map *l_next, *l_prev; /* Chain of loaded objects */ /* Plus additional fields private to the implementation */ }; RTLD_DL_SYMENT Obtain a pointer to the ELF symbol table entry of the matching symbol. The extra_info argument is a pointer to a symbol pointer: const ElfW(Sym) **. The ElfW() macro definition turns its argument into the name of an ELF data type suitable for the hardware architecture. For example, on a 64-bit platform, ElfW(Sym) yields the data type name Elf64_Sym, which is defined in <elf.h> as: typedef struct { Elf64_Word st_name; /* Symbol name */ unsigned char st_info; /* Symbol type and binding */ unsigned char st_other; /* Symbol visibility */ Elf64_Section st_shndx; /* Section index */ Elf64_Addr st_value; /* Symbol value */ Elf64_Xword st_size; /* Symbol size */ } Elf64_Sym; The st_name field is an index into the string table. The st_info field encodes the symbol's type and binding. The type can be extracted using the macro ELF64_ST_TYPE(st_info) (or ELF32_ST_TYPE() on 32-bit platforms), which yields one of the following values: Value Description STT_NOTYPE Symbol type is unspecified STT_OBJECT Symbol is a data object STT_FUNC Symbol is a code object STT_SECTION Symbol associated with a section STT_FILE Symbol's name is filename STT_COMMON Symbol is a common data object STT_TLS Symbol is thread-local data object STT_GNU_IFUNC Symbol is indirect code object The symbol binding can be extracted from the st_info field using the macro ELF64_ST_BIND(st_info) (or ELF32_ST_BIND() on 32-bit platforms), which yields one of the following values: Value Description STB_LOCAL Local symbol STB_GLOBAL Global symbol STB_WEAK Weak symbol STB_GNU_UNIQUE Unique symbol The st_other field contains the symbol's visibility, which can be extracted using the macro ELF64_ST_VISIBILITY(st_info) (or ELF32_ST_VISIBILITY() on 32-bit platforms), which yields one of the following values: Value Description STV_DEFAULT Default symbol visibility rules STV_INTERNAL Processor-specific hidden class STV_HIDDEN Symbol unavailable in other modules STV_PROTECTED Not preemptible, not exported RETURN VALUE On success, these functions return a nonzero value. If the address specified in addr could be matched to a shared object, but not to a sym- bol in the shared object, then the info->dli_sname and info->dli_saddr fields are set to NULL. If the address specified in addr could not be matched to a shared ob- ject, then these functions return 0. In this case, an error message is not available via dlerror(3). ATTRIBUTES For an explanation of the terms used in this section, see attributes(7). +--------------------------------------------+---------------+---------+ | Interface | Attribute | Value | +--------------------------------------------+---------------+---------+ | dladdr(), dladdr1() | Thread safety | MT-Safe | +--------------------------------------------+---------------+---------+ STANDARDS GNU. HISTORY dladdr() glibc 2.0. dladdr1() glibc 2.3.3. Solaris. BUGS Sometimes, the function pointers you pass to dladdr() may surprise you. On some architectures (notably i386 and x86-64), dli_fname and dli_fbase may end up pointing back at the object from which you called dladdr(), even if the function used as an argument should come from a dynamically linked library. The problem is that the function pointer will still be resolved at com- pile time, but merely point to the plt (Procedure Linkage Table) section of the original object (which dispatches the call after asking the dy- namic linker to resolve the symbol). To work around this, you can try to compile the code to be position-independent: then, the compiler can- not prepare the pointer at compile time any more and gcc(1) will gener- ate code that just loads the final symbol address from the got (Global Offset Table) at run time before passing it to dladdr(). SEE ALSO dl_iterate_phdr(3), dlinfo(3), dlopen(3), dlsym(3), ld.so(8) Linux man-pages 6.9.1 2024-05-02 dladdr(3)