1 /* Get public symbol information.
2 Copyright (C) 2002, 2003, 2004, 2005, 2008 Red Hat, Inc.
3 This file is part of elfutils.
4 Written by Ulrich Drepper <drepper@redhat.com>, 2002.
5
6 This file is free software; you can redistribute it and/or modify
7 it under the terms of either
8
9 * the GNU Lesser General Public License as published by the Free
10 Software Foundation; either version 3 of the License, or (at
11 your option) any later version
12
13 or
14
15 * the GNU General Public License as published by the Free
16 Software Foundation; either version 2 of the License, or (at
17 your option) any later version
18
19 or both in parallel, as here.
20
21 elfutils is distributed in the hope that it will be useful, but
22 WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24 General Public License for more details.
25
26 You should have received copies of the GNU General Public License and
27 the GNU Lesser General Public License along with this program. If
28 not, see <http://www.gnu.org/licenses/>. */
29
30 #ifdef HAVE_CONFIG_H
31 # include <config.h>
32 #endif
33
34 #include <assert.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #include <sys/param.h>
38
39 #include <libdwP.h>
40 #include <dwarf.h>
41
42
43 static int
get_offsets(Dwarf * dbg)44 get_offsets (Dwarf *dbg)
45 {
46 size_t allocated = 0;
47 size_t cnt = 0;
48 struct pubnames_s *mem = NULL;
49 const size_t entsize = sizeof (struct pubnames_s);
50 unsigned char *const startp = dbg->sectiondata[IDX_debug_pubnames]->d_buf;
51 unsigned char *readp = startp;
52 unsigned char *endp = readp + dbg->sectiondata[IDX_debug_pubnames]->d_size;
53
54 while (readp + 14 < endp)
55 {
56 /* If necessary, allocate more entries. */
57 if (cnt >= allocated)
58 {
59 allocated = MAX (10, 2 * allocated);
60 struct pubnames_s *newmem
61 = (struct pubnames_s *) realloc (mem, allocated * entsize);
62 if (newmem == NULL)
63 {
64 __libdw_seterrno (DWARF_E_NOMEM);
65 err_return:
66 free (mem);
67 return -1;
68 }
69
70 mem = newmem;
71 }
72
73 /* Read the set header. */
74 int len_bytes = 4;
75 Dwarf_Off len = read_4ubyte_unaligned_inc (dbg, readp);
76 if (len == DWARF3_LENGTH_64_BIT)
77 {
78 len = read_8ubyte_unaligned_inc (dbg, readp);
79 len_bytes = 8;
80 }
81 else if (unlikely (len >= DWARF3_LENGTH_MIN_ESCAPE_CODE
82 && len <= DWARF3_LENGTH_MAX_ESCAPE_CODE))
83 {
84 __libdw_seterrno (DWARF_E_INVALID_DWARF);
85 goto err_return;
86 }
87
88 /* Now we know the offset of the first offset/name pair. */
89 mem[cnt].set_start = readp + 2 + 2 * len_bytes - startp;
90 mem[cnt].address_len = len_bytes;
91 size_t max_size = dbg->sectiondata[IDX_debug_pubnames]->d_size;
92 if (mem[cnt].set_start >= max_size
93 || len - (2 + 2 * len_bytes) > max_size - mem[cnt].set_start)
94 /* Something wrong, the first entry is beyond the end of
95 the section. Or the length of the whole unit is too big. */
96 break;
97
98 /* Read the version. It better be two for now. */
99 uint16_t version = read_2ubyte_unaligned (dbg, readp);
100 if (unlikely (version != 2))
101 {
102 __libdw_seterrno (DWARF_E_INVALID_VERSION);
103 goto err_return;
104 }
105
106 /* Get the CU offset. */
107 if (__libdw_read_offset (dbg, dbg, IDX_debug_pubnames,
108 readp + 2, len_bytes,
109 &mem[cnt].cu_offset, IDX_debug_info, 3))
110 /* Error has been already set in reader. */
111 goto err_return;
112
113 /* Determine the size of the CU header. */
114 unsigned char *infop
115 = ((unsigned char *) dbg->sectiondata[IDX_debug_info]->d_buf
116 + mem[cnt].cu_offset);
117 if (read_4ubyte_unaligned_noncvt (infop) == DWARF3_LENGTH_64_BIT)
118 mem[cnt].cu_header_size = 23;
119 else
120 mem[cnt].cu_header_size = 11;
121
122 ++cnt;
123
124 /* Advance to the next set. */
125 readp += len;
126 }
127
128 if (mem == NULL || cnt == 0)
129 {
130 free (mem);
131 __libdw_seterrno (DWARF_E_NO_ENTRY);
132 return -1;
133 }
134
135 dbg->pubnames_sets = (struct pubnames_s *) realloc (mem, cnt * entsize);
136 dbg->pubnames_nsets = cnt;
137
138 return 0;
139 }
140
141
142 ptrdiff_t
dwarf_getpubnames(Dwarf * dbg,int (* callback)(Dwarf *,Dwarf_Global *,void *),void * arg,ptrdiff_t offset)143 dwarf_getpubnames (Dwarf *dbg,
144 int (*callback) (Dwarf *, Dwarf_Global *, void *),
145 void *arg, ptrdiff_t offset)
146 {
147 if (dbg == NULL)
148 return -1l;
149
150 if (unlikely (offset < 0))
151 {
152 __libdw_seterrno (DWARF_E_INVALID_OFFSET);
153 return -1l;
154 }
155
156 /* Make sure it is a valid offset. */
157 if (unlikely (dbg->sectiondata[IDX_debug_pubnames] == NULL
158 || ((size_t) offset
159 >= dbg->sectiondata[IDX_debug_pubnames]->d_size)))
160 /* No (more) entry. */
161 return 0;
162
163 /* If necessary read the set information. */
164 if (dbg->pubnames_nsets == 0 && unlikely (get_offsets (dbg) != 0))
165 return -1l;
166
167 /* Find the place where to start. */
168 size_t cnt;
169 if (offset == 0)
170 {
171 cnt = 0;
172 offset = dbg->pubnames_sets[0].set_start;
173 }
174 else
175 {
176 for (cnt = 0; cnt + 1 < dbg->pubnames_nsets; ++cnt)
177 if ((Dwarf_Off) offset >= dbg->pubnames_sets[cnt].set_start)
178 {
179 assert ((Dwarf_Off) offset
180 < dbg->pubnames_sets[cnt + 1].set_start);
181 break;
182 }
183 assert (cnt + 1 < dbg->pubnames_nsets);
184 }
185
186 unsigned char *startp
187 = (unsigned char *) dbg->sectiondata[IDX_debug_pubnames]->d_buf;
188 unsigned char *endp
189 = startp + dbg->sectiondata[IDX_debug_pubnames]->d_size;
190 unsigned char *readp = startp + offset;
191 while (1)
192 {
193 Dwarf_Global gl;
194
195 gl.cu_offset = (dbg->pubnames_sets[cnt].cu_offset
196 + dbg->pubnames_sets[cnt].cu_header_size);
197
198 while (1)
199 {
200 /* READP points to the next offset/name pair. */
201 if (readp + dbg->pubnames_sets[cnt].address_len > endp)
202 goto invalid_dwarf;
203 if (dbg->pubnames_sets[cnt].address_len == 4)
204 gl.die_offset = read_4ubyte_unaligned_inc (dbg, readp);
205 else
206 gl.die_offset = read_8ubyte_unaligned_inc (dbg, readp);
207
208 /* If the offset is zero we reached the end of the set. */
209 if (gl.die_offset == 0)
210 break;
211
212 /* Add the CU offset. */
213 gl.die_offset += dbg->pubnames_sets[cnt].cu_offset;
214
215 gl.name = (char *) readp;
216 readp = (unsigned char *) memchr (gl.name, '\0', endp - readp);
217 if (unlikely (readp == NULL))
218 {
219 invalid_dwarf:
220 __libdw_seterrno (DWARF_E_INVALID_DWARF);
221 return -1l;
222 }
223 readp++;
224
225 /* We found name and DIE offset. Report it. */
226 if (callback (dbg, &gl, arg) != DWARF_CB_OK)
227 {
228 /* The user wants us to stop. Return the offset of the
229 next entry. */
230 return readp - startp;
231 }
232 }
233
234 if (++cnt == dbg->pubnames_nsets)
235 /* This was the last set. */
236 break;
237
238 startp = (unsigned char *) dbg->sectiondata[IDX_debug_pubnames]->d_buf;
239 readp = startp + dbg->pubnames_sets[cnt].set_start;
240 }
241
242 /* We are done. No more entries. */
243 return 0;
244 }
245