• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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