Branch data Line data Source code
1 : : /* Get macro information.
2 : : Copyright (C) 2002-2009, 2014, 2017, 2018 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 <assert.h>
34 : : #include <dwarf.h>
35 : : #include <search.h>
36 : : #include <stdlib.h>
37 : : #include <string.h>
38 : :
39 : : #include <libdwP.h>
40 : :
41 : : static int
42 : 1070 : get_offset_from (Dwarf_Die *die, int name, Dwarf_Word *retp)
43 : : {
44 : : /* Get the appropriate attribute. */
45 : 1070 : Dwarf_Attribute attr;
46 [ + - ]: 1070 : if (INTUSE(dwarf_attr) (die, name, &attr) == NULL)
47 : : return -1;
48 : :
49 : : /* Offset into the corresponding section. */
50 : 1070 : return INTUSE(dwarf_formudata) (&attr, retp);
51 : : }
52 : :
53 : : static int
54 : 2270 : macro_op_compare (const void *p1, const void *p2)
55 : : {
56 : 2270 : const Dwarf_Macro_Op_Table *t1 = (const Dwarf_Macro_Op_Table *) p1;
57 : 2270 : const Dwarf_Macro_Op_Table *t2 = (const Dwarf_Macro_Op_Table *) p2;
58 : :
59 [ + + ]: 2270 : if (t1->offset < t2->offset)
60 : : return -1;
61 [ + + ]: 2190 : if (t1->offset > t2->offset)
62 : : return 1;
63 : :
64 [ + - ]: 1394 : if (t1->sec_index < t2->sec_index)
65 : : return -1;
66 [ - + ]: 1394 : if (t1->sec_index > t2->sec_index)
67 : 0 : return 1;
68 : :
69 : : return 0;
70 : : }
71 : :
72 : : static void
73 : 34 : build_table (Dwarf_Macro_Op_Table *table,
74 : : Dwarf_Macro_Op_Proto op_protos[static 255])
75 : : {
76 : 34 : unsigned ct = 0;
77 [ + + ]: 8704 : for (unsigned i = 1; i < 256; ++i)
78 [ + + ]: 8670 : if (op_protos[i - 1].forms != NULL)
79 : 342 : table->table[table->opcodes[i - 1] = ct++] = op_protos[i - 1];
80 : : else
81 : 8328 : table->opcodes[i - 1] = 0xff;
82 : 34 : }
83 : :
84 : : #define MACRO_PROTO(NAME, ...) \
85 : : Dwarf_Macro_Op_Proto NAME = ({ \
86 : : static const uint8_t proto[] = {__VA_ARGS__}; \
87 : : (Dwarf_Macro_Op_Proto) {sizeof proto, proto}; \
88 : : })
89 : :
90 : : enum { macinfo_data_size = offsetof (Dwarf_Macro_Op_Table, table[5]) };
91 : : static unsigned char macinfo_data[macinfo_data_size]
92 : : __attribute__ ((aligned (__alignof (Dwarf_Macro_Op_Table))));
93 : :
94 : : static __attribute__ ((constructor)) void
95 : 10 : init_macinfo_table (void)
96 : : {
97 : 10 : MACRO_PROTO (p_udata_str, DW_FORM_udata, DW_FORM_string);
98 : 10 : MACRO_PROTO (p_udata_udata, DW_FORM_udata, DW_FORM_udata);
99 : 10 : MACRO_PROTO (p_none);
100 : :
101 : 10 : Dwarf_Macro_Op_Proto op_protos[255] =
102 : : {
103 : : [DW_MACINFO_define - 1] = p_udata_str,
104 : : [DW_MACINFO_undef - 1] = p_udata_str,
105 : : [DW_MACINFO_vendor_ext - 1] = p_udata_str,
106 : : [DW_MACINFO_start_file - 1] = p_udata_udata,
107 : : [DW_MACINFO_end_file - 1] = p_none,
108 : : /* If you are adding more elements to this array, increase
109 : : MACINFO_DATA_SIZE above. */
110 : : };
111 : :
112 : 10 : Dwarf_Macro_Op_Table *macinfo_table = (void *) macinfo_data;
113 : 10 : memset (macinfo_table, 0, sizeof macinfo_data);
114 : 10 : build_table (macinfo_table, op_protos);
115 : 10 : macinfo_table->sec_index = IDX_debug_macinfo;
116 : 10 : }
117 : :
118 : : static Dwarf_Macro_Op_Table *
119 : 4 : get_macinfo_table (Dwarf *dbg, Dwarf_Word macoff, Dwarf_Die *cudie)
120 : : {
121 [ - + ]: 4 : assert (cudie != NULL);
122 : :
123 : 4 : Dwarf_Attribute attr_mem, *attr
124 : 4 : = INTUSE(dwarf_attr) (cudie, DW_AT_stmt_list, &attr_mem);
125 : 4 : Dwarf_Off line_offset = (Dwarf_Off) -1;
126 [ + - ]: 4 : if (attr != NULL)
127 [ + - ]: 4 : if (unlikely (INTUSE(dwarf_formudata) (attr, &line_offset) != 0))
128 : : return NULL;
129 : :
130 [ - + ]: 4 : Dwarf_Macro_Op_Table *table = libdw_alloc (dbg, Dwarf_Macro_Op_Table,
131 : : macinfo_data_size, 1);
132 : 4 : memcpy (table, macinfo_data, macinfo_data_size);
133 : :
134 : 4 : table->offset = macoff;
135 : 4 : table->sec_index = IDX_debug_macinfo;
136 : 4 : table->line_offset = line_offset;
137 : 4 : table->is_64bit = cudie->cu->address_size == 8;
138 : 4 : table->comp_dir = __libdw_getcompdir (cudie);
139 : :
140 : 4 : return table;
141 : : }
142 : :
143 : : static Dwarf_Macro_Op_Table *
144 : 24 : get_table_for_offset (Dwarf *dbg, Dwarf_Word macoff,
145 : : const unsigned char *readp,
146 : : const unsigned char *const endp,
147 : : Dwarf_Die *cudie)
148 : : {
149 : 24 : const unsigned char *startp = readp;
150 : :
151 : : /* Request at least 3 bytes for header. */
152 [ - + ]: 24 : if (readp + 3 > endp)
153 : : {
154 : 0 : invalid_dwarf:
155 : 0 : __libdw_seterrno (DWARF_E_INVALID_DWARF);
156 : 0 : return NULL;
157 : : }
158 : :
159 [ - + ]: 24 : uint16_t version = read_2ubyte_unaligned_inc (dbg, readp);
160 [ - + ]: 24 : if (version != 4 && version != 5)
161 : : {
162 : 0 : __libdw_seterrno (DWARF_E_INVALID_VERSION);
163 : 0 : return NULL;
164 : : }
165 : :
166 : 24 : uint8_t flags = *readp++;
167 : 24 : bool is_64bit = (flags & 0x1) != 0;
168 : :
169 : 24 : Dwarf_Off line_offset = (Dwarf_Off) -1;
170 [ + + ]: 24 : if ((flags & 0x2) != 0)
171 : : {
172 [ + - - + : 6 : line_offset = read_addr_unaligned_inc (is_64bit ? 8 : 4, dbg, readp);
- - ]
173 [ - + ]: 6 : if (readp > endp)
174 : 0 : goto invalid_dwarf;
175 : : }
176 [ - + ]: 18 : else if (cudie != NULL)
177 : : {
178 : 0 : Dwarf_Attribute attr_mem, *attr
179 : 0 : = INTUSE(dwarf_attr) (cudie, DW_AT_stmt_list, &attr_mem);
180 [ # # ]: 0 : if (attr != NULL)
181 [ # # ]: 0 : if (unlikely (INTUSE(dwarf_formudata) (attr, &line_offset) != 0))
182 : 0 : return NULL;
183 : : }
184 : :
185 : : /* """The macinfo entry types defined in this standard may, but
186 : : might not, be described in the table""".
187 : :
188 : : I.e. these may be present. It's tempting to simply skip them,
189 : : but it's probably more correct to tolerate that a producer tweaks
190 : : the way certain opcodes are encoded, for whatever reasons. */
191 : :
192 : 24 : MACRO_PROTO (p_udata_str, DW_FORM_udata, DW_FORM_string);
193 : 24 : MACRO_PROTO (p_udata_strp, DW_FORM_udata, DW_FORM_strp);
194 : 24 : MACRO_PROTO (p_udata_strsup, DW_FORM_udata, DW_FORM_strp_sup);
195 : 24 : MACRO_PROTO (p_udata_strx, DW_FORM_udata, DW_FORM_strx);
196 : 24 : MACRO_PROTO (p_udata_udata, DW_FORM_udata, DW_FORM_udata);
197 : 24 : MACRO_PROTO (p_secoffset, DW_FORM_sec_offset);
198 : 24 : MACRO_PROTO (p_none);
199 : :
200 : 24 : Dwarf_Macro_Op_Proto op_protos[255] =
201 : : {
202 : : [DW_MACRO_define - 1] = p_udata_str,
203 : : [DW_MACRO_undef - 1] = p_udata_str,
204 : : [DW_MACRO_define_strp - 1] = p_udata_strp,
205 : : [DW_MACRO_undef_strp - 1] = p_udata_strp,
206 : : [DW_MACRO_start_file - 1] = p_udata_udata,
207 : : [DW_MACRO_end_file - 1] = p_none,
208 : : [DW_MACRO_import - 1] = p_secoffset,
209 : : [DW_MACRO_define_sup - 1] = p_udata_strsup,
210 : : [DW_MACRO_undef_sup - 1] = p_udata_strsup,
211 : : [DW_MACRO_import_sup - 1] = p_secoffset, /* XXX - but in sup!. */
212 : : [DW_MACRO_define_strx - 1] = p_udata_strx,
213 : : [DW_MACRO_undef_strx - 1] = p_udata_strx,
214 : : };
215 : :
216 [ + + ]: 24 : if ((flags & 0x4) != 0)
217 : : {
218 : 4 : unsigned count = *readp++;
219 [ + + ]: 8 : for (unsigned i = 0; i < count; ++i)
220 : : {
221 : 4 : unsigned opcode = *readp++;
222 : :
223 : 4 : Dwarf_Macro_Op_Proto e;
224 [ - + ]: 4 : if (readp >= endp)
225 : 0 : goto invalid;
226 : 4 : get_uleb128 (e.nforms, readp, endp);
227 : 4 : e.forms = readp;
228 : 4 : op_protos[opcode - 1] = e;
229 : :
230 : 4 : readp += e.nforms;
231 [ - + ]: 4 : if (readp > endp)
232 : : {
233 : 0 : invalid:
234 : 0 : __libdw_seterrno (DWARF_E_INVALID_DWARF);
235 : 0 : return NULL;
236 : : }
237 : : }
238 : : }
239 : :
240 : 24 : size_t ct = 0;
241 [ + + ]: 6144 : for (unsigned i = 1; i < 256; ++i)
242 [ + + ]: 6120 : if (op_protos[i - 1].forms != NULL)
243 : 292 : ++ct;
244 : :
245 : : /* We support at most 0xfe opcodes defined in the table, as 0xff is
246 : : a value that means that given opcode is not stored at all. But
247 : : that should be fine, as opcode 0 is not allocated. */
248 [ - + ]: 24 : assert (ct < 0xff);
249 : :
250 : 24 : size_t macop_table_size = offsetof (Dwarf_Macro_Op_Table, table[ct]);
251 : :
252 [ + + ]: 24 : Dwarf_Macro_Op_Table *table = libdw_alloc (dbg, Dwarf_Macro_Op_Table,
253 : : macop_table_size, 1);
254 : :
255 : 48 : *table = (Dwarf_Macro_Op_Table) {
256 : : .offset = macoff,
257 : : .sec_index = IDX_debug_macro,
258 : : .line_offset = line_offset,
259 : 24 : .header_len = readp - startp,
260 : : .version = version,
261 : : .is_64bit = is_64bit,
262 : :
263 : : /* NULL if CUDIE is NULL or DW_AT_comp_dir is absent. */
264 : 24 : .comp_dir = __libdw_getcompdir (cudie),
265 : : };
266 : 24 : build_table (table, op_protos);
267 : :
268 : 24 : return table;
269 : : }
270 : :
271 : : static Dwarf_Macro_Op_Table *
272 : 1422 : cache_op_table (Dwarf *dbg, int sec_index, Dwarf_Off macoff,
273 : : const unsigned char *startp,
274 : : const unsigned char *const endp,
275 : : Dwarf_Die *cudie)
276 : : {
277 : 1422 : Dwarf_Macro_Op_Table fake = { .offset = macoff, .sec_index = sec_index };
278 : 1422 : Dwarf_Macro_Op_Table **found = tfind (&fake, &dbg->macro_ops,
279 : : macro_op_compare);
280 [ + + ]: 1422 : if (found != NULL)
281 : 1394 : return *found;
282 : :
283 : 56 : Dwarf_Macro_Op_Table *table = sec_index == IDX_debug_macro
284 : 24 : ? get_table_for_offset (dbg, macoff, startp, endp, cudie)
285 [ + + ]: 28 : : get_macinfo_table (dbg, macoff, cudie);
286 : :
287 [ - + ]: 28 : if (table == NULL)
288 : : return NULL;
289 : :
290 : 28 : Dwarf_Macro_Op_Table **ret = tsearch (table, &dbg->macro_ops,
291 : : macro_op_compare);
292 [ - + ]: 28 : if (unlikely (ret == NULL))
293 : : {
294 : 0 : __libdw_seterrno (DWARF_E_NOMEM);
295 : 0 : return NULL;
296 : : }
297 : :
298 : 28 : return *ret;
299 : : }
300 : :
301 : : static ptrdiff_t
302 : 1422 : read_macros (Dwarf *dbg, int sec_index,
303 : : Dwarf_Off macoff, int (*callback) (Dwarf_Macro *, void *),
304 : : void *arg, ptrdiff_t offset, bool accept_0xff,
305 : : Dwarf_Die *cudie)
306 : : {
307 : 1422 : Elf_Data *d = dbg->sectiondata[sec_index];
308 [ + - - + ]: 1422 : if (unlikely (d == NULL || d->d_buf == NULL))
309 : : {
310 : 0 : __libdw_seterrno (DWARF_E_NO_ENTRY);
311 : 0 : return -1;
312 : : }
313 : :
314 [ - + ]: 1422 : if (unlikely (macoff >= d->d_size))
315 : : {
316 : 0 : __libdw_seterrno (DWARF_E_INVALID_DWARF);
317 : 0 : return -1;
318 : : }
319 : :
320 : 1422 : const unsigned char *const startp = d->d_buf + macoff;
321 : 1422 : const unsigned char *const endp = d->d_buf + d->d_size;
322 : :
323 : 1422 : Dwarf_Macro_Op_Table *table = cache_op_table (dbg, sec_index, macoff,
324 : : startp, endp, cudie);
325 [ - + ]: 1422 : if (table == NULL)
326 : : return -1;
327 : :
328 [ + + ]: 1422 : if (offset == 0)
329 : 28 : offset = table->header_len;
330 : :
331 [ - + ]: 1422 : assert (offset >= 0);
332 [ - + ]: 1422 : assert (offset < endp - startp);
333 : 1422 : const unsigned char *readp = startp + offset;
334 : :
335 [ + - ]: 1422 : while (readp < endp)
336 : : {
337 : 1422 : unsigned int opcode = *readp++;
338 [ + + ]: 1422 : if (opcode == 0)
339 : : /* Nothing more to do. */
340 : 1422 : return 0;
341 : :
342 [ + + ]: 1396 : if (unlikely (opcode == 0xff && ! accept_0xff))
343 : : {
344 : : /* See comment below at dwarf_getmacros for explanation of
345 : : why we are doing this. */
346 : 2 : __libdw_seterrno (DWARF_E_INVALID_OPCODE);
347 : 2 : return -1;
348 : : }
349 : :
350 : 1394 : unsigned int idx = table->opcodes[opcode - 1];
351 [ - + ]: 1394 : if (idx == 0xff)
352 : : {
353 : 0 : __libdw_seterrno (DWARF_E_INVALID_OPCODE);
354 : 0 : return -1;
355 : : }
356 : :
357 : 1394 : Dwarf_Macro_Op_Proto *proto = &table->table[idx];
358 : :
359 : : /* A fake CU with bare minimum data to fool dwarf_formX into
360 : : doing the right thing with the attributes that we put out.
361 : : We pretend it is the same version as the actual table.
362 : : Version 4 for the old GNU extension, version 5 for DWARF5.
363 : : To handle DW_FORM_strx[1234] we set the .str_offsets_base
364 : : from the given CU.
365 : : XXX We will need to deal with DW_MACRO_import_sup and change
366 : : out the dbg somehow for the DW_FORM_sec_offset to make sense. */
367 : 4182 : Dwarf_CU fake_cu = {
368 : : .dbg = dbg,
369 : : .sec_idx = sec_index,
370 : 1394 : .version = table->version,
371 [ + + ]: 1394 : .offset_size = table->is_64bit ? 8 : 4,
372 [ + + ]: 1394 : .str_off_base = str_offsets_base_off (dbg, (cudie != NULL
373 : : ? cudie->cu: NULL)),
374 : : .startp = (void *) startp + offset,
375 : : .endp = (void *) endp,
376 : : };
377 : :
378 : 1394 : Dwarf_Attribute *attributes;
379 : 1394 : Dwarf_Attribute *attributesp = NULL;
380 : 1394 : Dwarf_Attribute nattributes[8];
381 [ - + ]: 1394 : if (unlikely (proto->nforms > 8))
382 : : {
383 : 0 : attributesp = malloc (sizeof (Dwarf_Attribute) * proto->nforms);
384 [ # # ]: 0 : if (attributesp == NULL)
385 : : {
386 : 0 : __libdw_seterrno (DWARF_E_NOMEM);
387 : 0 : return -1;
388 : : }
389 : : attributes = attributesp;
390 : : }
391 : : else
392 : : attributes = &nattributes[0];
393 : :
394 [ + + ]: 4108 : for (Dwarf_Word i = 0; i < proto->nforms; ++i)
395 : : {
396 : : /* We pretend this is a DW_AT[_GNU]_macros attribute so that
397 : : DW_FORM_sec_offset forms get correctly interpreted as
398 : : offset into .debug_macro. XXX Deal with DW_MACRO_import_sup
399 : : (swap .dbg) for DW_FORM_sec_offset? */
400 : 5428 : attributes[i].code = (fake_cu.version == 4 ? DW_AT_GNU_macros
401 [ + + ]: 2714 : : DW_AT_macros);
402 : 2714 : attributes[i].form = proto->forms[i];
403 : 2714 : attributes[i].valp = (void *) readp;
404 : 2714 : attributes[i].cu = &fake_cu;
405 : :
406 : : /* We don't want forms that aren't allowed because they could
407 : : read from the "abbrev" like DW_FORM_implicit_const. */
408 [ - + ]: 2714 : if (! libdw_valid_user_form (attributes[i].form))
409 : : {
410 : 0 : __libdw_seterrno (DWARF_E_INVALID_DWARF);
411 : 0 : free (attributesp);
412 : 0 : return -1;
413 : : }
414 : :
415 : 2714 : size_t len = __libdw_form_val_len (&fake_cu, proto->forms[i], readp);
416 [ - + ]: 2714 : if (unlikely (len == (size_t) -1))
417 : : {
418 : 0 : free (attributesp);
419 : 0 : return -1;
420 : : }
421 : :
422 : 2714 : readp += len;
423 : : }
424 : :
425 : 1394 : Dwarf_Macro macro = {
426 : : .table = table,
427 : : .opcode = opcode,
428 : : .attributes = attributes,
429 : : };
430 : :
431 : 1394 : int res = callback (¯o, arg);
432 [ - + ]: 1394 : if (unlikely (attributesp != NULL))
433 : 0 : free (attributesp);
434 : :
435 [ + - ]: 1394 : if (res != DWARF_CB_OK)
436 : 1394 : return readp - startp;
437 : : }
438 : :
439 : : return 0;
440 : : }
441 : :
442 : : /* Token layout:
443 : :
444 : : - The highest bit is used for distinguishing between callers that
445 : : know that opcode 0xff may have one of two incompatible meanings.
446 : : The mask that we use for selecting this bit is
447 : : DWARF_GETMACROS_START.
448 : :
449 : : - The rest of the token (31 or 63 bits) encodes address inside the
450 : : macro unit.
451 : :
452 : : Besides, token value of 0 signals end of iteration and -1 is
453 : : reserved for signaling errors. That means it's impossible to
454 : : represent maximum offset of a .debug_macro unit to new-style
455 : : callers (which in practice decreases the permissible macro unit
456 : : size by another 1 byte). */
457 : :
458 : : static ptrdiff_t
459 : 1422 : token_from_offset (ptrdiff_t offset, bool accept_0xff)
460 : : {
461 [ + + ]: 1422 : if (offset == -1 || offset == 0)
462 : : return offset;
463 : :
464 : : /* Make sure the offset didn't overflow into the flag bit. */
465 [ - + ]: 1394 : if ((offset & DWARF_GETMACROS_START) != 0)
466 : : {
467 : 0 : __libdw_seterrno (DWARF_E_TOO_BIG);
468 : 0 : return -1;
469 : : }
470 : :
471 [ + + ]: 1394 : if (accept_0xff)
472 : 342 : offset |= DWARF_GETMACROS_START;
473 : :
474 : : return offset;
475 : : }
476 : :
477 : : static ptrdiff_t
478 : 1422 : offset_from_token (ptrdiff_t token, bool *accept_0xffp)
479 : : {
480 : 1422 : *accept_0xffp = (token & DWARF_GETMACROS_START) != 0;
481 : 1422 : token &= ~DWARF_GETMACROS_START;
482 : :
483 : 1422 : return token;
484 : : }
485 : :
486 : : static ptrdiff_t
487 : 890 : gnu_macros_getmacros_off (Dwarf *dbg, Dwarf_Off macoff,
488 : : int (*callback) (Dwarf_Macro *, void *),
489 : : void *arg, ptrdiff_t offset, bool accept_0xff,
490 : : Dwarf_Die *cudie)
491 : : {
492 [ - + ]: 890 : assert (offset >= 0);
493 : :
494 [ - + ]: 890 : if (macoff >= dbg->sectiondata[IDX_debug_macro]->d_size)
495 : : {
496 : 0 : __libdw_seterrno (DWARF_E_INVALID_OFFSET);
497 : 0 : return -1;
498 : : }
499 : :
500 : 890 : return read_macros (dbg, IDX_debug_macro, macoff,
501 : : callback, arg, offset, accept_0xff, cudie);
502 : : }
503 : :
504 : : static ptrdiff_t
505 : 532 : macro_info_getmacros_off (Dwarf *dbg, Dwarf_Off macoff,
506 : : int (*callback) (Dwarf_Macro *, void *),
507 : : void *arg, ptrdiff_t offset, Dwarf_Die *cudie)
508 : : {
509 [ - + ]: 532 : assert (offset >= 0);
510 : :
511 : 532 : return read_macros (dbg, IDX_debug_macinfo, macoff,
512 : : callback, arg, offset, true, cudie);
513 : : }
514 : :
515 : : ptrdiff_t
516 : 352 : dwarf_getmacros_off (Dwarf *dbg, Dwarf_Off macoff,
517 : : int (*callback) (Dwarf_Macro *, void *),
518 : : void *arg, ptrdiff_t token)
519 : : {
520 [ - + ]: 352 : if (dbg == NULL)
521 : : {
522 : 0 : __libdw_seterrno (DWARF_E_NO_DWARF);
523 : 0 : return -1;
524 : : }
525 : :
526 : 352 : bool accept_0xff;
527 : 352 : ptrdiff_t offset = offset_from_token (token, &accept_0xff);
528 [ - + ]: 352 : assert (accept_0xff);
529 : :
530 : 352 : offset = gnu_macros_getmacros_off (dbg, macoff, callback, arg, offset,
531 : : accept_0xff, NULL);
532 : :
533 : 352 : return token_from_offset (offset, accept_0xff);
534 : : }
535 : :
536 : : ptrdiff_t
537 : 1070 : dwarf_getmacros (Dwarf_Die *cudie, int (*callback) (Dwarf_Macro *, void *),
538 : : void *arg, ptrdiff_t token)
539 : : {
540 [ - + ]: 1070 : if (cudie == NULL)
541 : : {
542 : 0 : __libdw_seterrno (DWARF_E_NO_DWARF);
543 : 0 : return -1;
544 : : }
545 : :
546 : : /* This function might be called from a code that expects to see
547 : : DW_MACINFO_* opcodes, not DW_MACRO_{GNU_,}* ones. It is fine to
548 : : serve most DW_MACRO_{GNU_,}* opcodes to such code, because those
549 : : whose values are the same as DW_MACINFO_* ones also have the same
550 : : behavior. It is not very likely that a .debug_macro section
551 : : would only use the part of opcode space that it shares with
552 : : .debug_macinfo, but it is possible. Serving the opcodes that are
553 : : only valid in DW_MACRO_{GNU_,}* domain is OK as well, because
554 : : clients in general need to be ready that newer standards define
555 : : more opcodes, and have coping mechanisms for unfamiliar opcodes.
556 : :
557 : : The one exception to the above rule is opcode 0xff, which has
558 : : concrete semantics in .debug_macinfo, but falls into vendor block
559 : : in .debug_macro, and can be assigned to do whatever. There is
560 : : some small probability that the two opcodes would look
561 : : superficially similar enough that a client would be confused and
562 : : misbehave as a result. For this reason, we refuse to serve
563 : : through this interface 0xff's originating from .debug_macro
564 : : unless the TOKEN that we obtained indicates the call originates
565 : : from a new-style caller. See above for details on what
566 : : information is encoded into tokens. */
567 : :
568 : 1070 : bool accept_0xff;
569 : 1070 : ptrdiff_t offset = offset_from_token (token, &accept_0xff);
570 : :
571 : : /* DW_AT_macro_info */
572 [ + + ]: 1070 : if (dwarf_hasattr (cudie, DW_AT_macro_info))
573 : : {
574 : 532 : Dwarf_Word macoff;
575 [ - + ]: 532 : if (get_offset_from (cudie, DW_AT_macro_info, &macoff) != 0)
576 : 0 : return -1;
577 : 532 : offset = macro_info_getmacros_off (cudie->cu->dbg, macoff,
578 : : callback, arg, offset, cudie);
579 : : }
580 : : else
581 : : {
582 : : /* DW_AT_GNU_macros, DW_AT_macros */
583 : 538 : Dwarf_Word macoff;
584 [ - + ]: 538 : if (get_offset_from (cudie, DW_AT_GNU_macros, &macoff) != 0
585 [ # # ]: 0 : && get_offset_from (cudie, DW_AT_macros, &macoff) != 0)
586 : 0 : return -1;
587 : 538 : offset = gnu_macros_getmacros_off (cudie->cu->dbg, macoff,
588 : : callback, arg, offset, accept_0xff,
589 : : cudie);
590 : : }
591 : :
592 : 1070 : return token_from_offset (offset, accept_0xff);
593 : : }
|
