Commit | Line | Data |
---|---|---|
c90ec28a TT |
1 | /* Read DWARF macro information |
2 | ||
3 | Copyright (C) 1994-2020 Free Software Foundation, Inc. | |
4 | ||
5 | Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology, | |
6 | Inc. with support from Florida State University (under contract | |
7 | with the Ada Joint Program Office), and Silicon Graphics, Inc. | |
8 | Initial contribution by Brent Benson, Harris Computer Systems, Inc., | |
9 | based on Fred Fish's (Cygnus Support) implementation of DWARF 1 | |
10 | support. | |
11 | ||
12 | This file is part of GDB. | |
13 | ||
14 | This program is free software; you can redistribute it and/or modify | |
15 | it under the terms of the GNU General Public License as published by | |
16 | the Free Software Foundation; either version 3 of the License, or | |
17 | (at your option) any later version. | |
18 | ||
19 | This program is distributed in the hope that it will be useful, | |
20 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
21 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
22 | GNU General Public License for more details. | |
23 | ||
24 | You should have received a copy of the GNU General Public License | |
25 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ | |
26 | ||
27 | #include "defs.h" | |
28 | #include "dwarf2/read.h" | |
29 | #include "dwarf2/leb.h" | |
30 | #include "dwarf2/expr.h" | |
31 | #include "dwarf2/line-header.h" | |
32 | #include "dwarf2/section.h" | |
33 | #include "dwarf2/macro.h" | |
34 | #include "dwarf2/dwz.h" | |
35 | #include "buildsym.h" | |
36 | #include "macrotab.h" | |
37 | #include "complaints.h" | |
38 | ||
39 | static void | |
40 | dwarf2_macro_malformed_definition_complaint (const char *arg1) | |
41 | { | |
42 | complaint (_("macro debug info contains a " | |
43 | "malformed macro definition:\n`%s'"), | |
44 | arg1); | |
45 | } | |
46 | ||
47 | static struct macro_source_file * | |
48 | macro_start_file (buildsym_compunit *builder, | |
49 | int file, int line, | |
50 | struct macro_source_file *current_file, | |
5a0e026f | 51 | const struct line_header *lh) |
c90ec28a TT |
52 | { |
53 | /* File name relative to the compilation directory of this source file. */ | |
54 | gdb::unique_xmalloc_ptr<char> file_name = lh->file_file_name (file); | |
55 | ||
56 | if (! current_file) | |
57 | { | |
58 | /* Note: We don't create a macro table for this compilation unit | |
59 | at all until we actually get a filename. */ | |
60 | struct macro_table *macro_table = builder->get_macro_table (); | |
61 | ||
62 | /* If we have no current file, then this must be the start_file | |
63 | directive for the compilation unit's main source file. */ | |
64 | current_file = macro_set_main (macro_table, file_name.get ()); | |
65 | macro_define_special (macro_table); | |
66 | } | |
67 | else | |
68 | current_file = macro_include (current_file, line, file_name.get ()); | |
69 | ||
70 | return current_file; | |
71 | } | |
72 | ||
73 | static const char * | |
74 | consume_improper_spaces (const char *p, const char *body) | |
75 | { | |
76 | if (*p == ' ') | |
77 | { | |
78 | complaint (_("macro definition contains spaces " | |
79 | "in formal argument list:\n`%s'"), | |
80 | body); | |
81 | ||
82 | while (*p == ' ') | |
83 | p++; | |
84 | } | |
85 | ||
86 | return p; | |
87 | } | |
88 | ||
89 | ||
90 | static void | |
91 | parse_macro_definition (struct macro_source_file *file, int line, | |
92 | const char *body) | |
93 | { | |
94 | const char *p; | |
95 | ||
96 | /* The body string takes one of two forms. For object-like macro | |
97 | definitions, it should be: | |
98 | ||
99 | <macro name> " " <definition> | |
100 | ||
101 | For function-like macro definitions, it should be: | |
102 | ||
103 | <macro name> "() " <definition> | |
104 | or | |
105 | <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition> | |
106 | ||
107 | Spaces may appear only where explicitly indicated, and in the | |
108 | <definition>. | |
109 | ||
110 | The Dwarf 2 spec says that an object-like macro's name is always | |
111 | followed by a space, but versions of GCC around March 2002 omit | |
112 | the space when the macro's definition is the empty string. | |
113 | ||
114 | The Dwarf 2 spec says that there should be no spaces between the | |
115 | formal arguments in a function-like macro's formal argument list, | |
116 | but versions of GCC around March 2002 include spaces after the | |
117 | commas. */ | |
118 | ||
119 | ||
120 | /* Find the extent of the macro name. The macro name is terminated | |
121 | by either a space or null character (for an object-like macro) or | |
122 | an opening paren (for a function-like macro). */ | |
123 | for (p = body; *p; p++) | |
124 | if (*p == ' ' || *p == '(') | |
125 | break; | |
126 | ||
127 | if (*p == ' ' || *p == '\0') | |
128 | { | |
129 | /* It's an object-like macro. */ | |
130 | int name_len = p - body; | |
131 | std::string name (body, name_len); | |
132 | const char *replacement; | |
133 | ||
134 | if (*p == ' ') | |
135 | replacement = body + name_len + 1; | |
136 | else | |
137 | { | |
138 | dwarf2_macro_malformed_definition_complaint (body); | |
139 | replacement = body + name_len; | |
140 | } | |
141 | ||
142 | macro_define_object (file, line, name.c_str (), replacement); | |
143 | } | |
144 | else if (*p == '(') | |
145 | { | |
146 | /* It's a function-like macro. */ | |
147 | std::string name (body, p - body); | |
148 | int argc = 0; | |
149 | int argv_size = 1; | |
150 | char **argv = XNEWVEC (char *, argv_size); | |
151 | ||
152 | p++; | |
153 | ||
154 | p = consume_improper_spaces (p, body); | |
155 | ||
156 | /* Parse the formal argument list. */ | |
157 | while (*p && *p != ')') | |
158 | { | |
159 | /* Find the extent of the current argument name. */ | |
160 | const char *arg_start = p; | |
161 | ||
162 | while (*p && *p != ',' && *p != ')' && *p != ' ') | |
163 | p++; | |
164 | ||
165 | if (! *p || p == arg_start) | |
166 | dwarf2_macro_malformed_definition_complaint (body); | |
167 | else | |
168 | { | |
169 | /* Make sure argv has room for the new argument. */ | |
170 | if (argc >= argv_size) | |
171 | { | |
172 | argv_size *= 2; | |
173 | argv = XRESIZEVEC (char *, argv, argv_size); | |
174 | } | |
175 | ||
176 | argv[argc++] = savestring (arg_start, p - arg_start); | |
177 | } | |
178 | ||
179 | p = consume_improper_spaces (p, body); | |
180 | ||
181 | /* Consume the comma, if present. */ | |
182 | if (*p == ',') | |
183 | { | |
184 | p++; | |
185 | ||
186 | p = consume_improper_spaces (p, body); | |
187 | } | |
188 | } | |
189 | ||
190 | if (*p == ')') | |
191 | { | |
192 | p++; | |
193 | ||
194 | if (*p == ' ') | |
195 | /* Perfectly formed definition, no complaints. */ | |
196 | macro_define_function (file, line, name.c_str (), | |
197 | argc, (const char **) argv, | |
198 | p + 1); | |
199 | else if (*p == '\0') | |
200 | { | |
201 | /* Complain, but do define it. */ | |
202 | dwarf2_macro_malformed_definition_complaint (body); | |
203 | macro_define_function (file, line, name.c_str (), | |
204 | argc, (const char **) argv, | |
205 | p); | |
206 | } | |
207 | else | |
208 | /* Just complain. */ | |
209 | dwarf2_macro_malformed_definition_complaint (body); | |
210 | } | |
211 | else | |
212 | /* Just complain. */ | |
213 | dwarf2_macro_malformed_definition_complaint (body); | |
214 | ||
215 | { | |
216 | int i; | |
217 | ||
218 | for (i = 0; i < argc; i++) | |
219 | xfree (argv[i]); | |
220 | } | |
221 | xfree (argv); | |
222 | } | |
223 | else | |
224 | dwarf2_macro_malformed_definition_complaint (body); | |
225 | } | |
226 | ||
227 | /* Skip some bytes from BYTES according to the form given in FORM. | |
228 | Returns the new pointer. */ | |
229 | ||
230 | static const gdb_byte * | |
231 | skip_form_bytes (bfd *abfd, const gdb_byte *bytes, const gdb_byte *buffer_end, | |
232 | enum dwarf_form form, | |
233 | unsigned int offset_size, | |
4f9c1eda | 234 | const struct dwarf2_section_info *section) |
c90ec28a TT |
235 | { |
236 | unsigned int bytes_read; | |
237 | ||
238 | switch (form) | |
239 | { | |
240 | case DW_FORM_data1: | |
241 | case DW_FORM_flag: | |
242 | ++bytes; | |
243 | break; | |
244 | ||
245 | case DW_FORM_data2: | |
246 | bytes += 2; | |
247 | break; | |
248 | ||
249 | case DW_FORM_data4: | |
250 | bytes += 4; | |
251 | break; | |
252 | ||
253 | case DW_FORM_data8: | |
254 | bytes += 8; | |
255 | break; | |
256 | ||
257 | case DW_FORM_data16: | |
258 | bytes += 16; | |
259 | break; | |
260 | ||
261 | case DW_FORM_string: | |
262 | read_direct_string (abfd, bytes, &bytes_read); | |
263 | bytes += bytes_read; | |
264 | break; | |
265 | ||
266 | case DW_FORM_sec_offset: | |
267 | case DW_FORM_strp: | |
268 | case DW_FORM_GNU_strp_alt: | |
269 | bytes += offset_size; | |
270 | break; | |
271 | ||
272 | case DW_FORM_block: | |
273 | bytes += read_unsigned_leb128 (abfd, bytes, &bytes_read); | |
274 | bytes += bytes_read; | |
275 | break; | |
276 | ||
277 | case DW_FORM_block1: | |
278 | bytes += 1 + read_1_byte (abfd, bytes); | |
279 | break; | |
280 | case DW_FORM_block2: | |
281 | bytes += 2 + read_2_bytes (abfd, bytes); | |
282 | break; | |
283 | case DW_FORM_block4: | |
284 | bytes += 4 + read_4_bytes (abfd, bytes); | |
285 | break; | |
286 | ||
287 | case DW_FORM_addrx: | |
288 | case DW_FORM_sdata: | |
289 | case DW_FORM_strx: | |
290 | case DW_FORM_udata: | |
291 | case DW_FORM_GNU_addr_index: | |
292 | case DW_FORM_GNU_str_index: | |
293 | bytes = gdb_skip_leb128 (bytes, buffer_end); | |
294 | if (bytes == NULL) | |
295 | { | |
296 | section->overflow_complaint (); | |
297 | return NULL; | |
298 | } | |
299 | break; | |
300 | ||
301 | case DW_FORM_implicit_const: | |
302 | break; | |
303 | ||
304 | default: | |
305 | { | |
306 | complaint (_("invalid form 0x%x in `%s'"), | |
307 | form, section->get_name ()); | |
308 | return NULL; | |
309 | } | |
310 | } | |
311 | ||
312 | return bytes; | |
313 | } | |
314 | ||
315 | /* A helper for dwarf_decode_macros that handles skipping an unknown | |
316 | opcode. Returns an updated pointer to the macro data buffer; or, | |
317 | on error, issues a complaint and returns NULL. */ | |
318 | ||
319 | static const gdb_byte * | |
320 | skip_unknown_opcode (unsigned int opcode, | |
321 | const gdb_byte **opcode_definitions, | |
322 | const gdb_byte *mac_ptr, const gdb_byte *mac_end, | |
323 | bfd *abfd, | |
324 | unsigned int offset_size, | |
4f9c1eda | 325 | const struct dwarf2_section_info *section) |
c90ec28a TT |
326 | { |
327 | unsigned int bytes_read, i; | |
328 | unsigned long arg; | |
329 | const gdb_byte *defn; | |
330 | ||
331 | if (opcode_definitions[opcode] == NULL) | |
332 | { | |
333 | complaint (_("unrecognized DW_MACFINO opcode 0x%x"), | |
334 | opcode); | |
335 | return NULL; | |
336 | } | |
337 | ||
338 | defn = opcode_definitions[opcode]; | |
339 | arg = read_unsigned_leb128 (abfd, defn, &bytes_read); | |
340 | defn += bytes_read; | |
341 | ||
342 | for (i = 0; i < arg; ++i) | |
343 | { | |
344 | mac_ptr = skip_form_bytes (abfd, mac_ptr, mac_end, | |
345 | (enum dwarf_form) defn[i], offset_size, | |
346 | section); | |
347 | if (mac_ptr == NULL) | |
348 | { | |
349 | /* skip_form_bytes already issued the complaint. */ | |
350 | return NULL; | |
351 | } | |
352 | } | |
353 | ||
354 | return mac_ptr; | |
355 | } | |
356 | ||
357 | /* A helper function which parses the header of a macro section. | |
358 | If the macro section is the extended (for now called "GNU") type, | |
359 | then this updates *OFFSET_SIZE. Returns a pointer to just after | |
360 | the header, or issues a complaint and returns NULL on error. */ | |
361 | ||
362 | static const gdb_byte * | |
363 | dwarf_parse_macro_header (const gdb_byte **opcode_definitions, | |
364 | bfd *abfd, | |
365 | const gdb_byte *mac_ptr, | |
366 | unsigned int *offset_size, | |
367 | int section_is_gnu) | |
368 | { | |
369 | memset (opcode_definitions, 0, 256 * sizeof (gdb_byte *)); | |
370 | ||
371 | if (section_is_gnu) | |
372 | { | |
373 | unsigned int version, flags; | |
374 | ||
375 | version = read_2_bytes (abfd, mac_ptr); | |
376 | if (version != 4 && version != 5) | |
377 | { | |
378 | complaint (_("unrecognized version `%d' in .debug_macro section"), | |
379 | version); | |
380 | return NULL; | |
381 | } | |
382 | mac_ptr += 2; | |
383 | ||
384 | flags = read_1_byte (abfd, mac_ptr); | |
385 | ++mac_ptr; | |
386 | *offset_size = (flags & 1) ? 8 : 4; | |
387 | ||
388 | if ((flags & 2) != 0) | |
389 | /* We don't need the line table offset. */ | |
390 | mac_ptr += *offset_size; | |
391 | ||
392 | /* Vendor opcode descriptions. */ | |
393 | if ((flags & 4) != 0) | |
394 | { | |
395 | unsigned int i, count; | |
396 | ||
397 | count = read_1_byte (abfd, mac_ptr); | |
398 | ++mac_ptr; | |
399 | for (i = 0; i < count; ++i) | |
400 | { | |
401 | unsigned int opcode, bytes_read; | |
402 | unsigned long arg; | |
403 | ||
404 | opcode = read_1_byte (abfd, mac_ptr); | |
405 | ++mac_ptr; | |
406 | opcode_definitions[opcode] = mac_ptr; | |
407 | arg = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); | |
408 | mac_ptr += bytes_read; | |
409 | mac_ptr += arg; | |
410 | } | |
411 | } | |
412 | } | |
413 | ||
414 | return mac_ptr; | |
415 | } | |
416 | ||
417 | /* A helper for dwarf_decode_macros that handles the GNU extensions, | |
418 | including DW_MACRO_import. */ | |
419 | ||
420 | static void | |
976ca316 | 421 | dwarf_decode_macro_bytes (dwarf2_per_objfile *per_objfile, |
c90ec28a TT |
422 | buildsym_compunit *builder, |
423 | bfd *abfd, | |
424 | const gdb_byte *mac_ptr, const gdb_byte *mac_end, | |
425 | struct macro_source_file *current_file, | |
5a0e026f | 426 | const struct line_header *lh, |
4f9c1eda | 427 | const struct dwarf2_section_info *section, |
c90ec28a TT |
428 | int section_is_gnu, int section_is_dwz, |
429 | unsigned int offset_size, | |
430 | htab_t include_hash) | |
431 | { | |
976ca316 | 432 | struct objfile *objfile = per_objfile->objfile; |
c90ec28a TT |
433 | enum dwarf_macro_record_type macinfo_type; |
434 | int at_commandline; | |
435 | const gdb_byte *opcode_definitions[256]; | |
436 | ||
437 | mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr, | |
438 | &offset_size, section_is_gnu); | |
439 | if (mac_ptr == NULL) | |
440 | { | |
441 | /* We already issued a complaint. */ | |
442 | return; | |
443 | } | |
444 | ||
445 | /* Determines if GDB is still before first DW_MACINFO_start_file. If true | |
446 | GDB is still reading the definitions from command line. First | |
447 | DW_MACINFO_start_file will need to be ignored as it was already executed | |
448 | to create CURRENT_FILE for the main source holding also the command line | |
449 | definitions. On first met DW_MACINFO_start_file this flag is reset to | |
450 | normally execute all the remaining DW_MACINFO_start_file macinfos. */ | |
451 | ||
452 | at_commandline = 1; | |
453 | ||
454 | do | |
455 | { | |
456 | /* Do we at least have room for a macinfo type byte? */ | |
457 | if (mac_ptr >= mac_end) | |
458 | { | |
459 | section->overflow_complaint (); | |
460 | break; | |
461 | } | |
462 | ||
463 | macinfo_type = (enum dwarf_macro_record_type) read_1_byte (abfd, mac_ptr); | |
464 | mac_ptr++; | |
465 | ||
466 | /* Note that we rely on the fact that the corresponding GNU and | |
467 | DWARF constants are the same. */ | |
468 | DIAGNOSTIC_PUSH | |
469 | DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES | |
470 | switch (macinfo_type) | |
471 | { | |
472 | /* A zero macinfo type indicates the end of the macro | |
473 | information. */ | |
474 | case 0: | |
475 | break; | |
476 | ||
477 | case DW_MACRO_define: | |
478 | case DW_MACRO_undef: | |
479 | case DW_MACRO_define_strp: | |
480 | case DW_MACRO_undef_strp: | |
481 | case DW_MACRO_define_sup: | |
482 | case DW_MACRO_undef_sup: | |
483 | { | |
484 | unsigned int bytes_read; | |
485 | int line; | |
486 | const char *body; | |
487 | int is_define; | |
488 | ||
489 | line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); | |
490 | mac_ptr += bytes_read; | |
491 | ||
492 | if (macinfo_type == DW_MACRO_define | |
493 | || macinfo_type == DW_MACRO_undef) | |
494 | { | |
495 | body = read_direct_string (abfd, mac_ptr, &bytes_read); | |
496 | mac_ptr += bytes_read; | |
497 | } | |
498 | else | |
499 | { | |
500 | LONGEST str_offset; | |
501 | ||
502 | str_offset = read_offset (abfd, mac_ptr, offset_size); | |
503 | mac_ptr += offset_size; | |
504 | ||
505 | if (macinfo_type == DW_MACRO_define_sup | |
506 | || macinfo_type == DW_MACRO_undef_sup | |
507 | || section_is_dwz) | |
508 | { | |
976ca316 | 509 | dwz_file *dwz = dwarf2_get_dwz_file (per_objfile->per_bfd); |
c90ec28a TT |
510 | |
511 | body = dwz->read_string (objfile, str_offset); | |
512 | } | |
513 | else | |
976ca316 SM |
514 | body = per_objfile->per_bfd->str.read_string (objfile, |
515 | str_offset, | |
516 | "DW_FORM_strp"); | |
c90ec28a TT |
517 | } |
518 | ||
519 | is_define = (macinfo_type == DW_MACRO_define | |
520 | || macinfo_type == DW_MACRO_define_strp | |
521 | || macinfo_type == DW_MACRO_define_sup); | |
522 | if (! current_file) | |
523 | { | |
524 | /* DWARF violation as no main source is present. */ | |
525 | complaint (_("debug info with no main source gives macro %s " | |
526 | "on line %d: %s"), | |
527 | is_define ? _("definition") : _("undefinition"), | |
528 | line, body); | |
529 | break; | |
530 | } | |
531 | if ((line == 0 && !at_commandline) | |
532 | || (line != 0 && at_commandline)) | |
533 | complaint (_("debug info gives %s macro %s with %s line %d: %s"), | |
534 | at_commandline ? _("command-line") : _("in-file"), | |
535 | is_define ? _("definition") : _("undefinition"), | |
536 | line == 0 ? _("zero") : _("non-zero"), line, body); | |
537 | ||
538 | if (body == NULL) | |
539 | { | |
540 | /* Fedora's rpm-build's "debugedit" binary | |
541 | corrupted .debug_macro sections. | |
542 | ||
543 | For more info, see | |
544 | https://bugzilla.redhat.com/show_bug.cgi?id=1708786 */ | |
545 | complaint (_("debug info gives %s invalid macro %s " | |
546 | "without body (corrupted?) at line %d " | |
547 | "on file %s"), | |
548 | at_commandline ? _("command-line") : _("in-file"), | |
549 | is_define ? _("definition") : _("undefinition"), | |
550 | line, current_file->filename); | |
551 | } | |
552 | else if (is_define) | |
553 | parse_macro_definition (current_file, line, body); | |
554 | else | |
555 | { | |
556 | gdb_assert (macinfo_type == DW_MACRO_undef | |
557 | || macinfo_type == DW_MACRO_undef_strp | |
558 | || macinfo_type == DW_MACRO_undef_sup); | |
559 | macro_undef (current_file, line, body); | |
560 | } | |
561 | } | |
562 | break; | |
563 | ||
564 | case DW_MACRO_start_file: | |
565 | { | |
566 | unsigned int bytes_read; | |
567 | int line, file; | |
568 | ||
569 | line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); | |
570 | mac_ptr += bytes_read; | |
571 | file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); | |
572 | mac_ptr += bytes_read; | |
573 | ||
574 | if ((line == 0 && !at_commandline) | |
575 | || (line != 0 && at_commandline)) | |
576 | complaint (_("debug info gives source %d included " | |
577 | "from %s at %s line %d"), | |
578 | file, at_commandline ? _("command-line") : _("file"), | |
579 | line == 0 ? _("zero") : _("non-zero"), line); | |
580 | ||
581 | if (at_commandline) | |
582 | { | |
583 | /* This DW_MACRO_start_file was executed in the | |
584 | pass one. */ | |
585 | at_commandline = 0; | |
586 | } | |
587 | else | |
588 | current_file = macro_start_file (builder, file, line, | |
589 | current_file, lh); | |
590 | } | |
591 | break; | |
592 | ||
593 | case DW_MACRO_end_file: | |
594 | if (! current_file) | |
595 | complaint (_("macro debug info has an unmatched " | |
596 | "`close_file' directive")); | |
597 | else | |
598 | { | |
599 | current_file = current_file->included_by; | |
600 | if (! current_file) | |
601 | { | |
602 | enum dwarf_macro_record_type next_type; | |
603 | ||
604 | /* GCC circa March 2002 doesn't produce the zero | |
605 | type byte marking the end of the compilation | |
606 | unit. Complain if it's not there, but exit no | |
607 | matter what. */ | |
608 | ||
609 | /* Do we at least have room for a macinfo type byte? */ | |
610 | if (mac_ptr >= mac_end) | |
611 | { | |
612 | section->overflow_complaint (); | |
613 | return; | |
614 | } | |
615 | ||
616 | /* We don't increment mac_ptr here, so this is just | |
617 | a look-ahead. */ | |
618 | next_type | |
619 | = (enum dwarf_macro_record_type) read_1_byte (abfd, | |
620 | mac_ptr); | |
621 | if (next_type != 0) | |
622 | complaint (_("no terminating 0-type entry for " | |
623 | "macros in `.debug_macinfo' section")); | |
624 | ||
625 | return; | |
626 | } | |
627 | } | |
628 | break; | |
629 | ||
630 | case DW_MACRO_import: | |
631 | case DW_MACRO_import_sup: | |
632 | { | |
633 | LONGEST offset; | |
634 | void **slot; | |
635 | bfd *include_bfd = abfd; | |
4f9c1eda | 636 | const struct dwarf2_section_info *include_section = section; |
c90ec28a TT |
637 | const gdb_byte *include_mac_end = mac_end; |
638 | int is_dwz = section_is_dwz; | |
639 | const gdb_byte *new_mac_ptr; | |
640 | ||
641 | offset = read_offset (abfd, mac_ptr, offset_size); | |
642 | mac_ptr += offset_size; | |
643 | ||
644 | if (macinfo_type == DW_MACRO_import_sup) | |
645 | { | |
976ca316 | 646 | dwz_file *dwz = dwarf2_get_dwz_file (per_objfile->per_bfd); |
c90ec28a TT |
647 | |
648 | dwz->macro.read (objfile); | |
649 | ||
650 | include_section = &dwz->macro; | |
651 | include_bfd = include_section->get_bfd_owner (); | |
652 | include_mac_end = dwz->macro.buffer + dwz->macro.size; | |
653 | is_dwz = 1; | |
654 | } | |
655 | ||
656 | new_mac_ptr = include_section->buffer + offset; | |
657 | slot = htab_find_slot (include_hash, new_mac_ptr, INSERT); | |
658 | ||
659 | if (*slot != NULL) | |
660 | { | |
661 | /* This has actually happened; see | |
662 | http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */ | |
663 | complaint (_("recursive DW_MACRO_import in " | |
664 | ".debug_macro section")); | |
665 | } | |
666 | else | |
667 | { | |
668 | *slot = (void *) new_mac_ptr; | |
669 | ||
976ca316 SM |
670 | dwarf_decode_macro_bytes (per_objfile, builder, include_bfd, |
671 | new_mac_ptr, include_mac_end, | |
672 | current_file, lh, section, | |
673 | section_is_gnu, is_dwz, offset_size, | |
674 | include_hash); | |
c90ec28a TT |
675 | |
676 | htab_remove_elt (include_hash, (void *) new_mac_ptr); | |
677 | } | |
678 | } | |
679 | break; | |
680 | ||
681 | case DW_MACINFO_vendor_ext: | |
682 | if (!section_is_gnu) | |
683 | { | |
684 | unsigned int bytes_read; | |
685 | ||
686 | /* This reads the constant, but since we don't recognize | |
687 | any vendor extensions, we ignore it. */ | |
688 | read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); | |
689 | mac_ptr += bytes_read; | |
690 | read_direct_string (abfd, mac_ptr, &bytes_read); | |
691 | mac_ptr += bytes_read; | |
692 | ||
693 | /* We don't recognize any vendor extensions. */ | |
694 | break; | |
695 | } | |
696 | /* FALLTHROUGH */ | |
697 | ||
698 | default: | |
699 | mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions, | |
700 | mac_ptr, mac_end, abfd, offset_size, | |
701 | section); | |
702 | if (mac_ptr == NULL) | |
703 | return; | |
704 | break; | |
705 | } | |
706 | DIAGNOSTIC_POP | |
707 | } while (macinfo_type != 0); | |
708 | } | |
709 | ||
710 | void | |
976ca316 | 711 | dwarf_decode_macros (dwarf2_per_objfile *per_objfile, |
4f9c1eda TT |
712 | buildsym_compunit *builder, |
713 | const dwarf2_section_info *section, | |
5a0e026f | 714 | const struct line_header *lh, unsigned int offset_size, |
c90ec28a TT |
715 | unsigned int offset, int section_is_gnu) |
716 | { | |
717 | bfd *abfd; | |
718 | const gdb_byte *mac_ptr, *mac_end; | |
719 | struct macro_source_file *current_file = 0; | |
720 | enum dwarf_macro_record_type macinfo_type; | |
721 | const gdb_byte *opcode_definitions[256]; | |
722 | void **slot; | |
723 | ||
724 | abfd = section->get_bfd_owner (); | |
725 | ||
726 | /* First pass: Find the name of the base filename. | |
727 | This filename is needed in order to process all macros whose definition | |
728 | (or undefinition) comes from the command line. These macros are defined | |
729 | before the first DW_MACINFO_start_file entry, and yet still need to be | |
730 | associated to the base file. | |
731 | ||
732 | To determine the base file name, we scan the macro definitions until we | |
733 | reach the first DW_MACINFO_start_file entry. We then initialize | |
734 | CURRENT_FILE accordingly so that any macro definition found before the | |
735 | first DW_MACINFO_start_file can still be associated to the base file. */ | |
736 | ||
737 | mac_ptr = section->buffer + offset; | |
738 | mac_end = section->buffer + section->size; | |
739 | ||
740 | mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr, | |
741 | &offset_size, section_is_gnu); | |
742 | if (mac_ptr == NULL) | |
743 | { | |
744 | /* We already issued a complaint. */ | |
745 | return; | |
746 | } | |
747 | ||
748 | do | |
749 | { | |
750 | /* Do we at least have room for a macinfo type byte? */ | |
751 | if (mac_ptr >= mac_end) | |
752 | { | |
753 | /* Complaint is printed during the second pass as GDB will probably | |
754 | stop the first pass earlier upon finding | |
755 | DW_MACINFO_start_file. */ | |
756 | break; | |
757 | } | |
758 | ||
759 | macinfo_type = (enum dwarf_macro_record_type) read_1_byte (abfd, mac_ptr); | |
760 | mac_ptr++; | |
761 | ||
762 | /* Note that we rely on the fact that the corresponding GNU and | |
763 | DWARF constants are the same. */ | |
764 | DIAGNOSTIC_PUSH | |
765 | DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES | |
766 | switch (macinfo_type) | |
767 | { | |
768 | /* A zero macinfo type indicates the end of the macro | |
769 | information. */ | |
770 | case 0: | |
771 | break; | |
772 | ||
773 | case DW_MACRO_define: | |
774 | case DW_MACRO_undef: | |
775 | /* Only skip the data by MAC_PTR. */ | |
776 | { | |
777 | unsigned int bytes_read; | |
778 | ||
779 | read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); | |
780 | mac_ptr += bytes_read; | |
781 | read_direct_string (abfd, mac_ptr, &bytes_read); | |
782 | mac_ptr += bytes_read; | |
783 | } | |
784 | break; | |
785 | ||
786 | case DW_MACRO_start_file: | |
787 | { | |
788 | unsigned int bytes_read; | |
789 | int line, file; | |
790 | ||
791 | line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); | |
792 | mac_ptr += bytes_read; | |
793 | file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); | |
794 | mac_ptr += bytes_read; | |
795 | ||
796 | current_file = macro_start_file (builder, file, line, | |
797 | current_file, lh); | |
798 | } | |
799 | break; | |
800 | ||
801 | case DW_MACRO_end_file: | |
802 | /* No data to skip by MAC_PTR. */ | |
803 | break; | |
804 | ||
805 | case DW_MACRO_define_strp: | |
806 | case DW_MACRO_undef_strp: | |
807 | case DW_MACRO_define_sup: | |
808 | case DW_MACRO_undef_sup: | |
809 | { | |
810 | unsigned int bytes_read; | |
811 | ||
812 | read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); | |
813 | mac_ptr += bytes_read; | |
814 | mac_ptr += offset_size; | |
815 | } | |
816 | break; | |
817 | ||
818 | case DW_MACRO_import: | |
819 | case DW_MACRO_import_sup: | |
820 | /* Note that, according to the spec, a transparent include | |
821 | chain cannot call DW_MACRO_start_file. So, we can just | |
822 | skip this opcode. */ | |
823 | mac_ptr += offset_size; | |
824 | break; | |
825 | ||
826 | case DW_MACINFO_vendor_ext: | |
827 | /* Only skip the data by MAC_PTR. */ | |
828 | if (!section_is_gnu) | |
829 | { | |
830 | unsigned int bytes_read; | |
831 | ||
832 | read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); | |
833 | mac_ptr += bytes_read; | |
834 | read_direct_string (abfd, mac_ptr, &bytes_read); | |
835 | mac_ptr += bytes_read; | |
836 | } | |
837 | /* FALLTHROUGH */ | |
838 | ||
839 | default: | |
840 | mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions, | |
841 | mac_ptr, mac_end, abfd, offset_size, | |
842 | section); | |
843 | if (mac_ptr == NULL) | |
844 | return; | |
845 | break; | |
846 | } | |
847 | DIAGNOSTIC_POP | |
848 | } while (macinfo_type != 0 && current_file == NULL); | |
849 | ||
850 | /* Second pass: Process all entries. | |
851 | ||
852 | Use the AT_COMMAND_LINE flag to determine whether we are still processing | |
853 | command-line macro definitions/undefinitions. This flag is unset when we | |
854 | reach the first DW_MACINFO_start_file entry. */ | |
855 | ||
856 | htab_up include_hash (htab_create_alloc (1, htab_hash_pointer, | |
857 | htab_eq_pointer, | |
858 | NULL, xcalloc, xfree)); | |
859 | mac_ptr = section->buffer + offset; | |
860 | slot = htab_find_slot (include_hash.get (), mac_ptr, INSERT); | |
861 | *slot = (void *) mac_ptr; | |
976ca316 SM |
862 | dwarf_decode_macro_bytes (per_objfile, builder, abfd, mac_ptr, mac_end, |
863 | current_file, lh, section, section_is_gnu, 0, | |
864 | offset_size, include_hash.get ()); | |
c90ec28a | 865 | } |