1 /* Test program for libdwfl symbol resolving
2 Copyright (C) 2013 Red Hat, Inc.
3 This file is part of elfutils.
4
5 This file is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 3 of the License, or
8 (at your option) any later version.
9
10 elfutils is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. */
17
18 #include <config.h>
19 #include <assert.h>
20 #include <inttypes.h>
21 #include ELFUTILS_HEADER(dwfl)
22 #include <elf.h>
23 #include <dwarf.h>
24 #include <argp.h>
25 #include <stdio.h>
26 #include <stdio_ext.h>
27 #include <stdlib.h>
28 #include <error.h>
29 #include <string.h>
30
31 static const char *
gelf_type(GElf_Sym * sym)32 gelf_type (GElf_Sym *sym)
33 {
34 switch (GELF_ST_TYPE (sym->st_info))
35 {
36 case STT_NOTYPE:
37 return "NOTYPE";
38 case STT_OBJECT:
39 return "OBJECT";
40 case STT_FUNC:
41 return "FUNC";
42 case STT_SECTION:
43 return "SECTION";
44 case STT_FILE:
45 return "FILE";
46 case STT_COMMON:
47 return "COMMON";
48 case STT_TLS:
49 return "TLS";
50 default:
51 return "UNKNOWN";
52 }
53 }
54
55 static const char *
gelf_bind(GElf_Sym * sym)56 gelf_bind (GElf_Sym *sym)
57 {
58 switch (GELF_ST_BIND (sym->st_info))
59 {
60 case STB_LOCAL:
61 return "LOCAL";
62 case STB_GLOBAL:
63 return "GLOBAL";
64 case STB_WEAK:
65 return "WEAK";
66 default:
67 return "UNKNOWN";
68 }
69 }
70
71 static int
gelf_bind_order(GElf_Sym * sym)72 gelf_bind_order (GElf_Sym *sym)
73 {
74 switch (GELF_ST_BIND (sym->st_info))
75 {
76 case STB_LOCAL:
77 return 1;
78 case STB_WEAK:
79 return 2;
80 case STB_GLOBAL:
81 return 3;
82 default:
83 return 0;
84 }
85 }
86
87 static const char *
elf_section_name(Elf * elf,GElf_Word shndx)88 elf_section_name (Elf *elf, GElf_Word shndx)
89 {
90 GElf_Ehdr ehdr;
91 GElf_Shdr shdr;
92 Elf_Scn *scn = elf_getscn (elf, shndx);
93 gelf_getshdr (scn, &shdr);
94 gelf_getehdr (elf, &ehdr);
95 return elf_strptr (elf, ehdr.e_shstrndx, shdr.sh_name);
96 }
97
98 bool
addr_in_section(Elf * elf,GElf_Word shndx,GElf_Addr addr)99 addr_in_section (Elf *elf, GElf_Word shndx, GElf_Addr addr)
100 {
101 GElf_Shdr shdr;
102 Elf_Scn *scn = elf_getscn (elf, shndx);
103 gelf_getshdr (scn, &shdr);
104 return addr >= shdr.sh_addr && addr < shdr.sh_addr + shdr.sh_size;
105 }
106
107 static int
list_syms(struct Dwfl_Module * mod,void ** user,const char * mod_name,Dwarf_Addr low_addr,void * arg)108 list_syms (struct Dwfl_Module *mod,
109 void **user __attribute__ ((unused)), const char *mod_name,
110 Dwarf_Addr low_addr __attribute__ ((unused)),
111 void *arg __attribute__ ((unused)))
112 {
113 int syms = dwfl_module_getsymtab (mod);
114 if (syms < 0)
115 {
116 printf ("%s: %s\n", mod_name, dwfl_errmsg (-1));
117 return DWARF_CB_OK;
118 }
119
120 for (int ndx = 0; ndx < syms; ndx++)
121 {
122 GElf_Sym sym;
123 GElf_Word shndxp;
124 Elf *elf;
125 Dwarf_Addr bias;
126 const char *name = dwfl_module_getsym (mod, ndx, &sym, &shndxp);
127
128 printf("%4d: %s\t%s\t%s (%" PRIu64 ") %#" PRIx64,
129 ndx, gelf_type (&sym), gelf_bind (&sym), name,
130 sym.st_size, sym.st_value);
131
132 /* The info variant doesn't adjust st_value but returns the (possible)
133 adjusted value separately. */
134 GElf_Addr value;
135 GElf_Sym isym;
136 name = dwfl_module_getsym_info (mod, ndx, &isym, &value, &shndxp,
137 &elf, &bias);
138
139 GElf_Ehdr ehdr;
140 gelf_getehdr (elf, &ehdr);
141
142 // getsym st_values might or might not be adjusted depending on section.
143 // For ET_REL the adjustment is section relative.
144 assert (sym.st_value == isym.st_value
145 || sym.st_value == isym.st_value + bias
146 || ehdr.e_type == ET_REL);
147
148 /* And the reverse, which works for function symbols at least.
149 Note this only works because the st.value is adjusted by
150 dwfl_module_getsym (). */
151 if (GELF_ST_TYPE (sym.st_info) == STT_FUNC && shndxp != SHN_UNDEF)
152 {
153 /* Make sure the adjusted value really falls in the elf section. */
154 assert (addr_in_section (elf, shndxp, sym.st_value - bias));
155
156 GElf_Addr addr = value;
157 GElf_Sym asym;
158 GElf_Word ashndxp;
159 Elf *aelf;
160 Dwarf_Addr abias;
161 GElf_Off off;
162 const char *aname = dwfl_module_addrinfo (mod, addr, &off, &asym,
163 &ashndxp, &aelf, &abias);
164
165 /* Make sure the adjusted value really falls in the elf section. */
166 assert (addr_in_section (aelf, ashndxp, asym.st_value)
167 || ehdr.e_type == ET_REL);
168
169 /* Either they are the same symbol (name), the binding of
170 asym is "stronger" (or equal) to sym or asym is more specific
171 (has a lower address) than sym. */
172 assert ((strcmp (name, aname) == 0
173 || gelf_bind_order (&asym) >= gelf_bind_order (&sym))
174 && value <= sym.st_value);
175
176 addr = sym.st_value;
177 int res = dwfl_module_relocate_address (mod, &addr);
178 assert (res != -1);
179 if (shndxp < SHN_LORESERVE)
180 printf(", rel: %#" PRIx64 " (%s)", addr,
181 elf_section_name (elf, shndxp));
182 else
183 printf(", rel: %#" PRIx64 "", addr);
184
185 /* Print the section of the actual value if different from sym. */
186 if (value != isym.st_value + bias && ehdr.e_type != ET_REL)
187 {
188 GElf_Addr ebias;
189 addr = value;
190 Elf_Scn *scn = dwfl_module_address_section (mod, &addr, &ebias);
191 GElf_Shdr shdr_mem;
192 GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
193 Elf *melf = dwfl_module_getelf (mod, &ebias);
194 gelf_getehdr (melf, &ehdr);
195 const char *sname = elf_strptr (melf, ehdr.e_shstrndx,
196 shdr->sh_name);
197 printf (" [%#" PRIx64 ", rel: %#" PRIx64 " (%s)]",
198 value, addr, sname);
199 }
200
201 }
202 printf ("\n");
203 }
204
205 return DWARF_CB_OK;
206 }
207
208 int
main(int argc,char * argv[])209 main (int argc, char *argv[])
210 {
211 int remaining;
212 Dwfl *dwfl;
213 error_t res;
214
215 res = argp_parse (dwfl_standard_argp (), argc, argv, 0, &remaining, &dwfl);
216 assert (res == 0 && dwfl != NULL);
217
218 ptrdiff_t off = 0;
219 do
220 off = dwfl_getmodules (dwfl, list_syms, NULL, off);
221 while (off > 0);
222
223 dwfl_end (dwfl);
224
225 return off;
226 }
227