1 /* Get macro information.
2 Copyright (C) 2002-2009, 2014, 2017, 2018 Red Hat, Inc.
3 This file is part of elfutils.
5 This file is free software; you can redistribute it and/or modify
6 it under the terms of either
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
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
18 or both in parallel, as here.
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.
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/>. */
42 get_offset_from (Dwarf_Die *die, int name, Dwarf_Word *retp)
44 /* Get the appropriate attribute. */
46 if (INTUSE(dwarf_attr) (die, name, &attr) == NULL)
49 /* Offset into the corresponding section. */
50 return INTUSE(dwarf_formudata) (&attr, retp);
54 macro_op_compare (const void *p1, const void *p2)
56 const Dwarf_Macro_Op_Table *t1 = (const Dwarf_Macro_Op_Table *) p1;
57 const Dwarf_Macro_Op_Table *t2 = (const Dwarf_Macro_Op_Table *) p2;
59 if (t1->offset < t2->offset)
61 if (t1->offset > t2->offset)
64 if (t1->sec_index < t2->sec_index)
66 if (t1->sec_index > t2->sec_index)
73 build_table (Dwarf_Macro_Op_Table *table,
74 Dwarf_Macro_Op_Proto op_protos[static 255])
77 for (unsigned i = 1; i < 256; ++i)
78 if (op_protos[i - 1].forms != NULL)
79 table->table[table->opcodes[i - 1] = ct++] = op_protos[i - 1];
81 table->opcodes[i - 1] = 0xff;
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}; \
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))));
94 static __attribute__ ((constructor)) void
95 init_macinfo_table (void)
97 MACRO_PROTO (p_udata_str, DW_FORM_udata, DW_FORM_string);
98 MACRO_PROTO (p_udata_udata, DW_FORM_udata, DW_FORM_udata);
101 Dwarf_Macro_Op_Proto op_protos[255] =
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. */
112 Dwarf_Macro_Op_Table *macinfo_table = (void *) macinfo_data;
113 memset (macinfo_table, 0, sizeof macinfo_data);
114 build_table (macinfo_table, op_protos);
115 macinfo_table->sec_index = IDX_debug_macinfo;
118 static Dwarf_Macro_Op_Table *
119 get_macinfo_table (Dwarf *dbg, Dwarf_Word macoff, Dwarf_Die *cudie)
121 assert (cudie != NULL);
123 Dwarf_Attribute attr_mem, *attr
124 = INTUSE(dwarf_attr) (cudie, DW_AT_stmt_list, &attr_mem);
125 Dwarf_Off line_offset = (Dwarf_Off) -1;
127 if (unlikely (INTUSE(dwarf_formudata) (attr, &line_offset) != 0))
130 Dwarf_Macro_Op_Table *table = libdw_alloc (dbg, Dwarf_Macro_Op_Table,
131 macinfo_data_size, 1);
132 memcpy (table, macinfo_data, macinfo_data_size);
134 table->offset = macoff;
135 table->sec_index = IDX_debug_macinfo;
136 table->line_offset = line_offset;
137 table->is_64bit = cudie->cu->address_size == 8;
138 table->comp_dir = __libdw_getcompdir (cudie);
143 static Dwarf_Macro_Op_Table *
144 get_table_for_offset (Dwarf *dbg, Dwarf_Word macoff,
145 const unsigned char *readp,
146 const unsigned char *const endp,
149 const unsigned char *startp = readp;
151 /* Request at least 3 bytes for header. */
152 if (readp + 3 > endp)
155 __libdw_seterrno (DWARF_E_INVALID_DWARF);
159 uint16_t version = read_2ubyte_unaligned_inc (dbg, readp);
160 if (version != 4 && version != 5)
162 __libdw_seterrno (DWARF_E_INVALID_VERSION);
166 uint8_t flags = *readp++;
167 bool is_64bit = (flags & 0x1) != 0;
169 Dwarf_Off line_offset = (Dwarf_Off) -1;
170 if ((flags & 0x2) != 0)
172 line_offset = read_addr_unaligned_inc (is_64bit ? 8 : 4, dbg, readp);
176 else if (cudie != NULL)
178 Dwarf_Attribute attr_mem, *attr
179 = INTUSE(dwarf_attr) (cudie, DW_AT_stmt_list, &attr_mem);
181 if (unlikely (INTUSE(dwarf_formudata) (attr, &line_offset) != 0))
185 /* """The macinfo entry types defined in this standard may, but
186 might not, be described in the table""".
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. */
192 MACRO_PROTO (p_udata_str, DW_FORM_udata, DW_FORM_string);
193 MACRO_PROTO (p_udata_strp, DW_FORM_udata, DW_FORM_strp);
194 MACRO_PROTO (p_udata_strsup, DW_FORM_udata, DW_FORM_strp_sup);
195 MACRO_PROTO (p_udata_strx, DW_FORM_udata, DW_FORM_strx);
196 MACRO_PROTO (p_udata_udata, DW_FORM_udata, DW_FORM_udata);
197 MACRO_PROTO (p_secoffset, DW_FORM_sec_offset);
198 MACRO_PROTO (p_none);
200 Dwarf_Macro_Op_Proto op_protos[255] =
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,
216 if ((flags & 0x4) != 0)
218 unsigned count = *readp++;
219 for (unsigned i = 0; i < count; ++i)
221 unsigned opcode = *readp++;
223 Dwarf_Macro_Op_Proto e;
226 get_uleb128 (e.nforms, readp, endp);
228 op_protos[opcode - 1] = e;
234 __libdw_seterrno (DWARF_E_INVALID_DWARF);
241 for (unsigned i = 1; i < 256; ++i)
242 if (op_protos[i - 1].forms != NULL)
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. */
250 size_t macop_table_size = offsetof (Dwarf_Macro_Op_Table, table[ct]);
252 Dwarf_Macro_Op_Table *table = libdw_alloc (dbg, Dwarf_Macro_Op_Table,
253 macop_table_size, 1);
255 *table = (Dwarf_Macro_Op_Table) {
257 .sec_index = IDX_debug_macro,
258 .line_offset = line_offset,
259 .header_len = readp - startp,
261 .is_64bit = is_64bit,
263 /* NULL if CUDIE is NULL or DW_AT_comp_dir is absent. */
264 .comp_dir = __libdw_getcompdir (cudie),
266 build_table (table, op_protos);
271 static Dwarf_Macro_Op_Table *
272 cache_op_table (Dwarf *dbg, int sec_index, Dwarf_Off macoff,
273 const unsigned char *startp,
274 const unsigned char *const endp,
277 Dwarf_Macro_Op_Table fake = { .offset = macoff, .sec_index = sec_index };
278 Dwarf_Macro_Op_Table **found = tfind (&fake, &dbg->macro_ops,
283 Dwarf_Macro_Op_Table *table = sec_index == IDX_debug_macro
284 ? get_table_for_offset (dbg, macoff, startp, endp, cudie)
285 : get_macinfo_table (dbg, macoff, cudie);
290 Dwarf_Macro_Op_Table **ret = tsearch (table, &dbg->macro_ops,
292 if (unlikely (ret == NULL))
294 __libdw_seterrno (DWARF_E_NOMEM);
302 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,
307 Elf_Data *d = dbg->sectiondata[sec_index];
308 if (unlikely (d == NULL || d->d_buf == NULL))
310 __libdw_seterrno (DWARF_E_NO_ENTRY);
314 if (unlikely (macoff >= d->d_size))
316 __libdw_seterrno (DWARF_E_INVALID_DWARF);
320 const unsigned char *const startp = d->d_buf + macoff;
321 const unsigned char *const endp = d->d_buf + d->d_size;
323 Dwarf_Macro_Op_Table *table = cache_op_table (dbg, sec_index, macoff,
324 startp, endp, cudie);
329 offset = table->header_len;
331 assert (offset >= 0);
332 assert (offset < endp - startp);
333 const unsigned char *readp = startp + offset;
337 unsigned int opcode = *readp++;
339 /* Nothing more to do. */
342 if (unlikely (opcode == 0xff && ! accept_0xff))
344 /* See comment below at dwarf_getmacros for explanation of
345 why we are doing this. */
346 __libdw_seterrno (DWARF_E_INVALID_OPCODE);
350 unsigned int idx = table->opcodes[opcode - 1];
353 __libdw_seterrno (DWARF_E_INVALID_OPCODE);
357 Dwarf_Macro_Op_Proto *proto = &table->table[idx];
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
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. */
369 .sec_idx = sec_index,
370 .version = table->version,
371 .offset_size = table->is_64bit ? 8 : 4,
372 .str_off_base = str_offsets_base_off (dbg, (cudie != NULL
374 .startp = (void *) startp + offset,
375 .endp = (void *) endp,
378 Dwarf_Attribute *attributes;
379 Dwarf_Attribute *attributesp = NULL;
380 Dwarf_Attribute nattributes[8];
381 if (unlikely (proto->nforms > 8))
383 attributesp = malloc (sizeof (Dwarf_Attribute) * proto->nforms);
384 if (attributesp == NULL)
386 __libdw_seterrno (DWARF_E_NOMEM);
389 attributes = attributesp;
392 attributes = &nattributes[0];
394 for (Dwarf_Word i = 0; i < proto->nforms; ++i)
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 attributes[i].code = (fake_cu.version == 4 ? DW_AT_GNU_macros
402 attributes[i].form = proto->forms[i];
403 attributes[i].valp = (void *) readp;
404 attributes[i].cu = &fake_cu;
406 /* We don't want forms that aren't allowed because they could
407 read from the "abbrev" like DW_FORM_implicit_const. */
408 if (! libdw_valid_user_form (attributes[i].form))
410 __libdw_seterrno (DWARF_E_INVALID_DWARF);
415 size_t len = __libdw_form_val_len (&fake_cu, proto->forms[i], readp);
416 if (unlikely (len == (size_t) -1))
425 Dwarf_Macro macro = {
428 .attributes = attributes,
431 int res = callback (¯o, arg);
432 if (unlikely (attributesp != NULL))
435 if (res != DWARF_CB_OK)
436 return readp - startp;
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.
449 - The rest of the token (31 or 63 bits) encodes address inside the
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). */
459 token_from_offset (ptrdiff_t offset, bool accept_0xff)
461 if (offset == -1 || offset == 0)
464 /* Make sure the offset didn't overflow into the flag bit. */
465 if ((offset & DWARF_GETMACROS_START) != 0)
467 __libdw_seterrno (DWARF_E_TOO_BIG);
472 offset |= DWARF_GETMACROS_START;
478 offset_from_token (ptrdiff_t token, bool *accept_0xffp)
480 *accept_0xffp = (token & DWARF_GETMACROS_START) != 0;
481 token &= ~DWARF_GETMACROS_START;
487 gnu_macros_getmacros_off (Dwarf *dbg, Dwarf_Off macoff,
488 int (*callback) (Dwarf_Macro *, void *),
489 void *arg, ptrdiff_t offset, bool accept_0xff,
492 assert (offset >= 0);
494 if (macoff >= dbg->sectiondata[IDX_debug_macro]->d_size)
496 __libdw_seterrno (DWARF_E_INVALID_OFFSET);
500 return read_macros (dbg, IDX_debug_macro, macoff,
501 callback, arg, offset, accept_0xff, cudie);
505 macro_info_getmacros_off (Dwarf *dbg, Dwarf_Off macoff,
506 int (*callback) (Dwarf_Macro *, void *),
507 void *arg, ptrdiff_t offset, Dwarf_Die *cudie)
509 assert (offset >= 0);
511 return read_macros (dbg, IDX_debug_macinfo, macoff,
512 callback, arg, offset, true, cudie);
516 dwarf_getmacros_off (Dwarf *dbg, Dwarf_Off macoff,
517 int (*callback) (Dwarf_Macro *, void *),
518 void *arg, ptrdiff_t token)
522 __libdw_seterrno (DWARF_E_NO_DWARF);
527 ptrdiff_t offset = offset_from_token (token, &accept_0xff);
528 assert (accept_0xff);
530 offset = gnu_macros_getmacros_off (dbg, macoff, callback, arg, offset,
533 return token_from_offset (offset, accept_0xff);
537 dwarf_getmacros (Dwarf_Die *cudie, int (*callback) (Dwarf_Macro *, void *),
538 void *arg, ptrdiff_t token)
542 __libdw_seterrno (DWARF_E_NO_DWARF);
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.
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. */
569 ptrdiff_t offset = offset_from_token (token, &accept_0xff);
571 /* DW_AT_macro_info */
572 if (dwarf_hasattr (cudie, DW_AT_macro_info))
575 if (get_offset_from (cudie, DW_AT_macro_info, &macoff) != 0)
577 offset = macro_info_getmacros_off (cudie->cu->dbg, macoff,
578 callback, arg, offset, cudie);
582 /* DW_AT_GNU_macros, DW_AT_macros */
584 if (get_offset_from (cudie, DW_AT_GNU_macros, &macoff) != 0
585 && get_offset_from (cudie, DW_AT_macros, &macoff) != 0)
587 offset = gnu_macros_getmacros_off (cudie->cu->dbg, macoff,
588 callback, arg, offset, accept_0xff,
592 return token_from_offset (offset, accept_0xff);