Branch data Line data Source code
1 : : /* Keeping track of DWARF compilation units in libdwfl.
2 : : Copyright (C) 2005-2010, 2015, 2016, 2017 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 either
7 : :
8 : : * the GNU Lesser General Public License as published by the Free
9 : : Software Foundation; either version 3 of the License, or (at
10 : : your option) any later version
11 : :
12 : : or
13 : :
14 : : * the GNU General Public License as published by the Free
15 : : Software Foundation; either version 2 of the License, or (at
16 : : your option) any later version
17 : :
18 : : or both in parallel, as here.
19 : :
20 : : elfutils is distributed in the hope that it will be useful, but
21 : : WITHOUT ANY WARRANTY; without even the implied warranty of
22 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 : : General Public License for more details.
24 : :
25 : : You should have received copies of the GNU General Public License and
26 : : the GNU Lesser General Public License along with this program. If
27 : : not, see <http://www.gnu.org/licenses/>. */
28 : :
29 : : #ifdef HAVE_CONFIG_H
30 : : # include <config.h>
31 : : #endif
32 : :
33 : : #include "libdwflP.h"
34 : : #include "libdwP.h"
35 : : #include "memory-access.h"
36 : : #include <search.h>
37 : :
38 : :
39 : : static inline Dwarf_Arange *
40 : 519 : dwar (Dwfl_Module *mod, unsigned int idx)
41 : : {
42 : 519 : return &mod->dw->aranges->info[mod->aranges[idx].arange];
43 : : }
44 : :
45 : :
46 : : static Dwfl_Error
47 : 450 : addrarange (Dwfl_Module *mod, Dwarf_Addr addr, struct dwfl_arange **arange)
48 : : {
49 [ + + ]: 450 : if (mod->aranges == NULL)
50 : : {
51 : 66 : struct dwfl_arange *aranges = NULL;
52 : 66 : Dwarf_Aranges *dwaranges = NULL;
53 : 66 : size_t naranges;
54 [ + - ]: 66 : if (INTUSE(dwarf_getaranges) (mod->dw, &dwaranges, &naranges) != 0)
55 : 0 : return DWFL_E_LIBDW;
56 : :
57 : : /* If the module has no aranges (when no code is included) we
58 : : allocate nothing. */
59 [ + + ]: 66 : if (naranges != 0)
60 : : {
61 : 58 : aranges = malloc (naranges * sizeof *aranges);
62 [ + - ]: 58 : if (unlikely (aranges == NULL))
63 : : return DWFL_E_NOMEM;
64 : :
65 : : /* libdw has sorted its list by address, which is how we want it.
66 : : But the sorted list is full of not-quite-contiguous runs pointing
67 : : to the same CU. We don't care about the little gaps inside the
68 : : module, we'll consider them part of the surrounding CU anyway.
69 : : Collect our own array with just one record for each run of ranges
70 : : pointing to one CU. */
71 : :
72 : 58 : naranges = 0;
73 : 58 : Dwarf_Off lastcu = 0;
74 [ + + ]: 143 : for (size_t i = 0; i < dwaranges->naranges; ++i)
75 [ + + + + ]: 85 : if (i == 0 || dwaranges->info[i].offset != lastcu)
76 : : {
77 : 77 : aranges[naranges].arange = i;
78 : 77 : aranges[naranges].cu = NULL;
79 : 77 : ++naranges;
80 : 77 : lastcu = dwaranges->info[i].offset;
81 : : }
82 : : }
83 : :
84 : : /* Store the final array, which is probably much smaller than before. */
85 : 66 : mod->naranges = naranges;
86 [ + + ]: 66 : if (naranges > 0)
87 : 58 : mod->aranges = (realloc (aranges, naranges * sizeof aranges[0])
88 [ - + ]: 58 : ?: aranges);
89 [ - + ]: 8 : else if (aranges != NULL)
90 : 0 : free (aranges);
91 : 66 : mod->lazycu += naranges;
92 : : }
93 : :
94 : : /* The address must be inside the module to begin with. */
95 : 450 : addr = dwfl_deadjust_dwarf_addr (mod, addr);
96 : :
97 : : /* The ranges are sorted by address, so we can use binary search. */
98 : 450 : size_t l = 0, u = mod->naranges;
99 [ + + ]: 488 : while (l < u)
100 : : {
101 : 480 : size_t idx = (l + u) / 2;
102 : 480 : Dwarf_Addr start = dwar (mod, idx)->addr;
103 [ - + ]: 480 : if (addr < start)
104 : : {
105 : 0 : u = idx;
106 : 0 : continue;
107 : : }
108 [ + + ]: 480 : else if (addr > start)
109 : : {
110 [ + + ]: 364 : if (idx + 1 < mod->naranges)
111 : : {
112 [ + + ]: 39 : if (addr >= dwar (mod, idx + 1)->addr)
113 : : {
114 : 38 : l = idx + 1;
115 : 38 : continue;
116 : : }
117 : : }
118 : : else
119 : : {
120 : : /* It might be in the last range. */
121 : 325 : const Dwarf_Arange *last
122 : 325 : = &mod->dw->aranges->info[mod->dw->aranges->naranges - 1];
123 [ + - ]: 325 : if (addr > last->addr + last->length)
124 : : break;
125 : : }
126 : : }
127 : :
128 : 442 : *arange = &mod->aranges[idx];
129 : 442 : return DWFL_E_NOERROR;
130 : : }
131 : :
132 : : return DWFL_E_ADDR_OUTOFRANGE;
133 : : }
134 : :
135 : :
136 : : static void
137 : 0 : nofree (void *arg)
138 : : {
139 : 0 : struct dwfl_cu *cu = arg;
140 [ # # ]: 0 : if (cu == (void *) -1l)
141 : : return;
142 : :
143 [ # # ]: 0 : assert (cu->mod->lazycu == 0);
144 : : }
145 : :
146 : : /* One reason fewer to keep the lazy lookup table for CUs. */
147 : : static inline void
148 : 63 : less_lazy (Dwfl_Module *mod)
149 : : {
150 [ - + ]: 63 : if (--mod->lazycu > 0)
151 : : return;
152 : :
153 : : /* We know about all the CUs now, we don't need this table. */
154 : 0 : tdestroy (mod->lazy_cu_root, nofree);
155 : 0 : mod->lazy_cu_root = NULL;
156 : : }
157 : :
158 : : static inline Dwarf_Off
159 : 111514 : cudie_offset (const struct dwfl_cu *cu)
160 : : {
161 : 111514 : return __libdw_first_die_off_from_cu (cu->die.cu);
162 : : }
163 : :
164 : : static int
165 : 111514 : compare_cukey (const void *a, const void *b)
166 : : {
167 : 111514 : Dwarf_Off a_off = cudie_offset (a);
168 : 111514 : Dwarf_Off b_off = cudie_offset (b);
169 [ + + ]: 111514 : return (a_off < b_off) ? -1 : ((a_off > b_off) ? 1 : 0);
170 : : }
171 : :
172 : : /* Intern the CU if necessary. */
173 : : static Dwfl_Error
174 : 9628 : intern_cu (Dwfl_Module *mod, Dwarf_Off cuoff, struct dwfl_cu **result)
175 : : {
176 [ - + ]: 9628 : if (unlikely (cuoff + 4 >= mod->dw->sectiondata[IDX_debug_info]->d_size))
177 : : {
178 [ # # ]: 0 : if (likely (mod->lazycu == 1))
179 : : {
180 : : /* This is the EOF marker. Now we have interned all the CUs.
181 : : One increment in MOD->lazycu counts not having hit EOF yet. */
182 : 0 : *result = (void *) -1;
183 : 0 : less_lazy (mod);
184 : 0 : return DWFL_E_NOERROR;
185 : : }
186 : : else
187 : : {
188 : : /* Unexpected EOF, most likely a bogus aranges. */
189 : : return (DWFL_E (LIBDW, DWARF_E_INVALID_DWARF));
190 : : }
191 : : }
192 : :
193 : : /* Make sure the cuoff points to a real DIE. */
194 : 9628 : Dwarf_Die cudie;
195 : 9628 : Dwarf_Die *die = INTUSE(dwarf_offdie) (mod->dw, cuoff, &cudie);
196 [ + - ]: 9628 : if (die == NULL)
197 : : return DWFL_E_LIBDW;
198 : :
199 : 9628 : struct dwfl_cu key;
200 : 9628 : key.die.cu = die->cu;
201 : 9628 : struct dwfl_cu **found = tsearch (&key, &mod->lazy_cu_root, &compare_cukey);
202 [ + - ]: 9628 : if (unlikely (found == NULL))
203 : : return DWFL_E_NOMEM;
204 : :
205 [ + + - + ]: 9628 : if (*found == &key || *found == NULL)
206 : : {
207 : : /* This is a new entry, meaning we haven't looked at this CU. */
208 : :
209 : 9627 : *found = NULL;
210 : :
211 : 9627 : struct dwfl_cu *cu = malloc (sizeof *cu);
212 [ + - ]: 9627 : if (unlikely (cu == NULL))
213 : : return DWFL_E_NOMEM;
214 : :
215 : 9627 : cu->mod = mod;
216 : 9627 : cu->next = NULL;
217 : 9627 : cu->lines = NULL;
218 : 9627 : cu->die = cudie;
219 : :
220 : 9627 : struct dwfl_cu **newvec = realloc (mod->cu, ((mod->ncu + 1)
221 : : * sizeof (mod->cu[0])));
222 [ - + ]: 9627 : if (newvec == NULL)
223 : : {
224 : 0 : free (cu);
225 : 0 : return DWFL_E_NOMEM;
226 : : }
227 : 9627 : mod->cu = newvec;
228 : :
229 : 9627 : mod->cu[mod->ncu++] = cu;
230 [ + + ]: 9627 : if (cu->die.cu->start == 0)
231 : 138 : mod->first_cu = cu;
232 : :
233 : 9627 : *found = cu;
234 : : }
235 : :
236 : 9628 : *result = *found;
237 : 9628 : return DWFL_E_NOERROR;
238 : : }
239 : :
240 : :
241 : : /* Traverse all the CUs in the module. */
242 : :
243 : : Dwfl_Error
244 : : internal_function
245 : 9670 : __libdwfl_nextcu (Dwfl_Module *mod, struct dwfl_cu *lastcu,
246 : : struct dwfl_cu **cu)
247 : : {
248 : 9670 : Dwarf_Off cuoff;
249 : 9670 : struct dwfl_cu **nextp;
250 : :
251 [ + + ]: 9670 : if (lastcu == NULL)
252 : : {
253 : : /* Start the traversal. */
254 : 94 : cuoff = 0;
255 : 94 : nextp = &mod->first_cu;
256 : : }
257 : : else
258 : : {
259 : : /* Continue following LASTCU. */
260 : 9576 : cuoff = lastcu->die.cu->end;
261 : 9576 : nextp = &lastcu->next;
262 : : }
263 : :
264 [ + + ]: 9670 : if (*nextp == NULL)
265 : : {
266 : 9659 : size_t cuhdrsz;
267 : 9659 : Dwarf_Off nextoff;
268 : 9659 : int end = INTUSE(dwarf_nextcu) (mod->dw, cuoff, &nextoff, &cuhdrsz,
269 : : NULL, NULL, NULL);
270 [ + - ]: 9659 : if (end < 0)
271 : 94 : return DWFL_E_LIBDW;
272 [ + + ]: 9659 : if (end > 0)
273 : : {
274 : 94 : *cu = NULL;
275 : 94 : return DWFL_E_NOERROR;
276 : : }
277 : :
278 : 9565 : Dwfl_Error result = intern_cu (mod, cuoff + cuhdrsz, nextp);
279 [ + - ]: 9565 : if (result != DWFL_E_NOERROR)
280 : : return result;
281 : :
282 [ + - ]: 9565 : if (*nextp != (void *) -1
283 [ + - - + ]: 9565 : && (*nextp)->next == NULL && nextoff == (Dwarf_Off) -1l)
284 : 0 : (*nextp)->next = (void *) -1l;
285 : : }
286 : :
287 [ + - ]: 9576 : *cu = *nextp == (void *) -1l ? NULL : *nextp;
288 : 9576 : return DWFL_E_NOERROR;
289 : : }
290 : :
291 : :
292 : : /* Intern the CU arange points to, if necessary. */
293 : :
294 : : static Dwfl_Error
295 : 442 : arangecu (Dwfl_Module *mod, struct dwfl_arange *arange, struct dwfl_cu **cu)
296 : : {
297 [ + + ]: 442 : if (arange->cu == NULL)
298 : : {
299 : 63 : const Dwarf_Arange *dwarange = &mod->dw->aranges->info[arange->arange];
300 : 63 : Dwfl_Error result = intern_cu (mod, dwarange->offset, &arange->cu);
301 [ + - ]: 63 : if (result != DWFL_E_NOERROR)
302 : : return result;
303 [ - + ]: 63 : assert (arange->cu != NULL && arange->cu != (void *) -1l);
304 : 63 : less_lazy (mod); /* Each arange with null ->cu counts once. */
305 : : }
306 : :
307 : 442 : *cu = arange->cu;
308 : 442 : return DWFL_E_NOERROR;
309 : : }
310 : :
311 : : Dwfl_Error
312 : : internal_function
313 : 450 : __libdwfl_addrcu (Dwfl_Module *mod, Dwarf_Addr addr, struct dwfl_cu **cu)
314 : : {
315 : 450 : struct dwfl_arange *arange;
316 [ + + ]: 450 : return addrarange (mod, addr, &arange) ?: arangecu (mod, arange, cu);
317 : : }
|
