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, | |
dda83cd7 SM |
50 | struct macro_source_file *current_file, |
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 == ' ') | |
dda83cd7 | 83 | p++; |
c90ec28a TT |
84 | } |
85 | ||
86 | return p; | |
87 | } | |
88 | ||
89 | ||
90 | static void | |
91 | parse_macro_definition (struct macro_source_file *file, int line, | |
dda83cd7 | 92 | const char *body) |
c90ec28a TT |
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 | ||
dda83cd7 | 99 | <macro name> " " <definition> |
c90ec28a TT |
100 | |
101 | For function-like macro definitions, it should be: | |
102 | ||
dda83cd7 | 103 | <macro name> "() " <definition> |
c90ec28a | 104 | or |
dda83cd7 | 105 | <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition> |
c90ec28a TT |
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 == ' ') | |
dda83cd7 | 135 | replacement = body + name_len + 1; |
c90ec28a | 136 | else |
dda83cd7 | 137 | { |
c90ec28a | 138 | dwarf2_macro_malformed_definition_complaint (body); |
dda83cd7 SM |
139 | replacement = body + name_len; |
140 | } | |
c90ec28a TT |
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 != ')') | |
dda83cd7 SM |
158 | { |
159 | /* Find the extent of the current argument name. */ | |
160 | const char *arg_start = p; | |
c90ec28a | 161 | |
dda83cd7 SM |
162 | while (*p && *p != ',' && *p != ')' && *p != ' ') |
163 | p++; | |
c90ec28a | 164 | |
dda83cd7 | 165 | if (! *p || p == arg_start) |
c90ec28a | 166 | dwarf2_macro_malformed_definition_complaint (body); |
dda83cd7 SM |
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 | } | |
c90ec28a | 178 | |
dda83cd7 | 179 | p = consume_improper_spaces (p, body); |
c90ec28a | 180 | |
dda83cd7 SM |
181 | /* Consume the comma, if present. */ |
182 | if (*p == ',') | |
183 | { | |
184 | p++; | |
c90ec28a | 185 | |
dda83cd7 SM |
186 | p = consume_improper_spaces (p, body); |
187 | } | |
188 | } | |
c90ec28a TT |
189 | |
190 | if (*p == ')') | |
dda83cd7 SM |
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. */ | |
c90ec28a | 202 | dwarf2_macro_malformed_definition_complaint (body); |
dda83cd7 SM |
203 | macro_define_function (file, line, name.c_str (), |
204 | argc, (const char **) argv, | |
205 | p); | |
206 | } | |
207 | else | |
208 | /* Just complain. */ | |
c90ec28a | 209 | dwarf2_macro_malformed_definition_complaint (body); |
dda83cd7 | 210 | } |
c90ec28a | 211 | else |
dda83cd7 | 212 | /* Just complain. */ |
c90ec28a TT |
213 | dwarf2_macro_malformed_definition_complaint (body); |
214 | ||
215 | { | |
dda83cd7 | 216 | int i; |
c90ec28a | 217 | |
dda83cd7 SM |
218 | for (i = 0; i < argc; i++) |
219 | xfree (argv[i]); | |
c90ec28a TT |
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, | |
048fde1e | 430 | struct dwarf2_section_info *str_section, |
431 | struct dwarf2_section_info *str_offsets_section, | |
432 | ULONGEST str_offsets_base, | |
c90ec28a TT |
433 | htab_t include_hash) |
434 | { | |
976ca316 | 435 | struct objfile *objfile = per_objfile->objfile; |
c90ec28a TT |
436 | enum dwarf_macro_record_type macinfo_type; |
437 | int at_commandline; | |
438 | const gdb_byte *opcode_definitions[256]; | |
439 | ||
440 | mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr, | |
441 | &offset_size, section_is_gnu); | |
442 | if (mac_ptr == NULL) | |
443 | { | |
444 | /* We already issued a complaint. */ | |
445 | return; | |
446 | } | |
447 | ||
448 | /* Determines if GDB is still before first DW_MACINFO_start_file. If true | |
449 | GDB is still reading the definitions from command line. First | |
450 | DW_MACINFO_start_file will need to be ignored as it was already executed | |
451 | to create CURRENT_FILE for the main source holding also the command line | |
452 | definitions. On first met DW_MACINFO_start_file this flag is reset to | |
453 | normally execute all the remaining DW_MACINFO_start_file macinfos. */ | |
454 | ||
455 | at_commandline = 1; | |
456 | ||
457 | do | |
458 | { | |
459 | /* Do we at least have room for a macinfo type byte? */ | |
460 | if (mac_ptr >= mac_end) | |
461 | { | |
462 | section->overflow_complaint (); | |
463 | break; | |
464 | } | |
465 | ||
466 | macinfo_type = (enum dwarf_macro_record_type) read_1_byte (abfd, mac_ptr); | |
467 | mac_ptr++; | |
468 | ||
469 | /* Note that we rely on the fact that the corresponding GNU and | |
470 | DWARF constants are the same. */ | |
471 | DIAGNOSTIC_PUSH | |
472 | DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES | |
473 | switch (macinfo_type) | |
474 | { | |
475 | /* A zero macinfo type indicates the end of the macro | |
476 | information. */ | |
477 | case 0: | |
478 | break; | |
479 | ||
dda83cd7 SM |
480 | case DW_MACRO_define: |
481 | case DW_MACRO_undef: | |
c90ec28a TT |
482 | case DW_MACRO_define_strp: |
483 | case DW_MACRO_undef_strp: | |
484 | case DW_MACRO_define_sup: | |
485 | case DW_MACRO_undef_sup: | |
dda83cd7 SM |
486 | { |
487 | unsigned int bytes_read; | |
488 | int line; | |
489 | const char *body; | |
c90ec28a TT |
490 | int is_define; |
491 | ||
492 | line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); | |
493 | mac_ptr += bytes_read; | |
494 | ||
495 | if (macinfo_type == DW_MACRO_define | |
496 | || macinfo_type == DW_MACRO_undef) | |
497 | { | |
498 | body = read_direct_string (abfd, mac_ptr, &bytes_read); | |
499 | mac_ptr += bytes_read; | |
500 | } | |
501 | else | |
502 | { | |
503 | LONGEST str_offset; | |
504 | ||
505 | str_offset = read_offset (abfd, mac_ptr, offset_size); | |
506 | mac_ptr += offset_size; | |
507 | ||
508 | if (macinfo_type == DW_MACRO_define_sup | |
509 | || macinfo_type == DW_MACRO_undef_sup | |
510 | || section_is_dwz) | |
511 | { | |
976ca316 | 512 | dwz_file *dwz = dwarf2_get_dwz_file (per_objfile->per_bfd); |
c90ec28a TT |
513 | |
514 | body = dwz->read_string (objfile, str_offset); | |
515 | } | |
516 | else | |
976ca316 SM |
517 | body = per_objfile->per_bfd->str.read_string (objfile, |
518 | str_offset, | |
519 | "DW_FORM_strp"); | |
c90ec28a TT |
520 | } |
521 | ||
522 | is_define = (macinfo_type == DW_MACRO_define | |
523 | || macinfo_type == DW_MACRO_define_strp | |
524 | || macinfo_type == DW_MACRO_define_sup); | |
dda83cd7 | 525 | if (! current_file) |
c90ec28a TT |
526 | { |
527 | /* DWARF violation as no main source is present. */ | |
528 | complaint (_("debug info with no main source gives macro %s " | |
529 | "on line %d: %s"), | |
530 | is_define ? _("definition") : _("undefinition"), | |
531 | line, body); | |
532 | break; | |
533 | } | |
534 | if ((line == 0 && !at_commandline) | |
535 | || (line != 0 && at_commandline)) | |
536 | complaint (_("debug info gives %s macro %s with %s line %d: %s"), | |
537 | at_commandline ? _("command-line") : _("in-file"), | |
538 | is_define ? _("definition") : _("undefinition"), | |
539 | line == 0 ? _("zero") : _("non-zero"), line, body); | |
540 | ||
541 | if (body == NULL) | |
542 | { | |
543 | /* Fedora's rpm-build's "debugedit" binary | |
544 | corrupted .debug_macro sections. | |
545 | ||
546 | For more info, see | |
547 | https://bugzilla.redhat.com/show_bug.cgi?id=1708786 */ | |
548 | complaint (_("debug info gives %s invalid macro %s " | |
549 | "without body (corrupted?) at line %d " | |
550 | "on file %s"), | |
551 | at_commandline ? _("command-line") : _("in-file"), | |
552 | is_define ? _("definition") : _("undefinition"), | |
553 | line, current_file->filename); | |
554 | } | |
555 | else if (is_define) | |
556 | parse_macro_definition (current_file, line, body); | |
557 | else | |
558 | { | |
559 | gdb_assert (macinfo_type == DW_MACRO_undef | |
560 | || macinfo_type == DW_MACRO_undef_strp | |
561 | || macinfo_type == DW_MACRO_undef_sup); | |
562 | macro_undef (current_file, line, body); | |
563 | } | |
dda83cd7 SM |
564 | } |
565 | break; | |
c90ec28a | 566 | |
048fde1e | 567 | case DW_MACRO_define_strx: |
568 | case DW_MACRO_undef_strx: | |
569 | { | |
570 | unsigned int bytes_read; | |
571 | ||
572 | int line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); | |
573 | mac_ptr += bytes_read; | |
574 | int offset_index = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); | |
575 | mac_ptr += bytes_read; | |
576 | ||
577 | str_offsets_section->read (objfile); | |
578 | const gdb_byte *info_ptr = (str_offsets_section->buffer | |
579 | + str_offsets_base | |
580 | + offset_index * offset_size); | |
581 | ||
582 | const char *macinfo_str = (macinfo_type == DW_MACRO_define_strx ? | |
583 | "DW_MACRO_define_strx" : "DW_MACRO_undef_strx"); | |
584 | ||
585 | if (str_offsets_base + offset_index * offset_size | |
586 | >= str_offsets_section->size) | |
587 | { | |
588 | complaint (_("%s pointing outside of .debug_str_offsets section " | |
589 | "[in module %s]"), macinfo_str, objfile_name (objfile)); | |
590 | break; | |
591 | } | |
592 | ||
593 | ULONGEST str_offset = read_offset (abfd, info_ptr, offset_size); | |
594 | ||
595 | const char *body = str_section->read_string (objfile, str_offset, | |
596 | macinfo_str); | |
597 | if (current_file == nullptr) | |
598 | { | |
599 | /* DWARF violation as no main source is present. */ | |
600 | complaint (_("debug info with no main source gives macro %s " | |
601 | "on line %d: %s"), | |
602 | macinfo_type == DW_MACRO_define_strx ? _("definition") | |
603 | : _("undefinition"), line, body); | |
604 | break; | |
605 | } | |
606 | ||
607 | if (macinfo_type == DW_MACRO_define_strx) | |
608 | parse_macro_definition (current_file, line, body); | |
609 | else | |
610 | macro_undef (current_file, line, body); | |
611 | } | |
612 | break; | |
613 | ||
dda83cd7 SM |
614 | case DW_MACRO_start_file: |
615 | { | |
616 | unsigned int bytes_read; | |
617 | int line, file; | |
c90ec28a | 618 | |
dda83cd7 SM |
619 | line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); |
620 | mac_ptr += bytes_read; | |
621 | file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); | |
622 | mac_ptr += bytes_read; | |
c90ec28a TT |
623 | |
624 | if ((line == 0 && !at_commandline) | |
625 | || (line != 0 && at_commandline)) | |
626 | complaint (_("debug info gives source %d included " | |
627 | "from %s at %s line %d"), | |
628 | file, at_commandline ? _("command-line") : _("file"), | |
629 | line == 0 ? _("zero") : _("non-zero"), line); | |
630 | ||
631 | if (at_commandline) | |
632 | { | |
633 | /* This DW_MACRO_start_file was executed in the | |
634 | pass one. */ | |
635 | at_commandline = 0; | |
636 | } | |
637 | else | |
638 | current_file = macro_start_file (builder, file, line, | |
639 | current_file, lh); | |
dda83cd7 SM |
640 | } |
641 | break; | |
c90ec28a | 642 | |
dda83cd7 SM |
643 | case DW_MACRO_end_file: |
644 | if (! current_file) | |
c90ec28a TT |
645 | complaint (_("macro debug info has an unmatched " |
646 | "`close_file' directive")); | |
dda83cd7 SM |
647 | else |
648 | { | |
649 | current_file = current_file->included_by; | |
650 | if (! current_file) | |
651 | { | |
652 | enum dwarf_macro_record_type next_type; | |
653 | ||
654 | /* GCC circa March 2002 doesn't produce the zero | |
655 | type byte marking the end of the compilation | |
656 | unit. Complain if it's not there, but exit no | |
657 | matter what. */ | |
658 | ||
659 | /* Do we at least have room for a macinfo type byte? */ | |
660 | if (mac_ptr >= mac_end) | |
661 | { | |
c90ec28a | 662 | section->overflow_complaint (); |
dda83cd7 SM |
663 | return; |
664 | } | |
c90ec28a | 665 | |
dda83cd7 SM |
666 | /* We don't increment mac_ptr here, so this is just |
667 | a look-ahead. */ | |
668 | next_type | |
c90ec28a TT |
669 | = (enum dwarf_macro_record_type) read_1_byte (abfd, |
670 | mac_ptr); | |
dda83cd7 | 671 | if (next_type != 0) |
c90ec28a TT |
672 | complaint (_("no terminating 0-type entry for " |
673 | "macros in `.debug_macinfo' section")); | |
674 | ||
dda83cd7 SM |
675 | return; |
676 | } | |
677 | } | |
678 | break; | |
c90ec28a TT |
679 | |
680 | case DW_MACRO_import: | |
681 | case DW_MACRO_import_sup: | |
682 | { | |
683 | LONGEST offset; | |
684 | void **slot; | |
685 | bfd *include_bfd = abfd; | |
4f9c1eda | 686 | const struct dwarf2_section_info *include_section = section; |
c90ec28a TT |
687 | const gdb_byte *include_mac_end = mac_end; |
688 | int is_dwz = section_is_dwz; | |
689 | const gdb_byte *new_mac_ptr; | |
690 | ||
691 | offset = read_offset (abfd, mac_ptr, offset_size); | |
692 | mac_ptr += offset_size; | |
693 | ||
694 | if (macinfo_type == DW_MACRO_import_sup) | |
695 | { | |
976ca316 | 696 | dwz_file *dwz = dwarf2_get_dwz_file (per_objfile->per_bfd); |
c90ec28a TT |
697 | |
698 | dwz->macro.read (objfile); | |
699 | ||
700 | include_section = &dwz->macro; | |
701 | include_bfd = include_section->get_bfd_owner (); | |
702 | include_mac_end = dwz->macro.buffer + dwz->macro.size; | |
703 | is_dwz = 1; | |
704 | } | |
705 | ||
706 | new_mac_ptr = include_section->buffer + offset; | |
707 | slot = htab_find_slot (include_hash, new_mac_ptr, INSERT); | |
708 | ||
709 | if (*slot != NULL) | |
710 | { | |
711 | /* This has actually happened; see | |
712 | http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */ | |
713 | complaint (_("recursive DW_MACRO_import in " | |
714 | ".debug_macro section")); | |
715 | } | |
716 | else | |
717 | { | |
718 | *slot = (void *) new_mac_ptr; | |
719 | ||
976ca316 SM |
720 | dwarf_decode_macro_bytes (per_objfile, builder, include_bfd, |
721 | new_mac_ptr, include_mac_end, | |
722 | current_file, lh, section, | |
723 | section_is_gnu, is_dwz, offset_size, | |
048fde1e | 724 | str_section, str_offsets_section, |
725 | str_offsets_base, include_hash); | |
c90ec28a TT |
726 | |
727 | htab_remove_elt (include_hash, (void *) new_mac_ptr); | |
728 | } | |
729 | } | |
730 | break; | |
731 | ||
dda83cd7 | 732 | case DW_MACINFO_vendor_ext: |
c90ec28a TT |
733 | if (!section_is_gnu) |
734 | { | |
735 | unsigned int bytes_read; | |
736 | ||
737 | /* This reads the constant, but since we don't recognize | |
738 | any vendor extensions, we ignore it. */ | |
739 | read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); | |
740 | mac_ptr += bytes_read; | |
741 | read_direct_string (abfd, mac_ptr, &bytes_read); | |
742 | mac_ptr += bytes_read; | |
743 | ||
744 | /* We don't recognize any vendor extensions. */ | |
745 | break; | |
746 | } | |
747 | /* FALLTHROUGH */ | |
748 | ||
749 | default: | |
750 | mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions, | |
751 | mac_ptr, mac_end, abfd, offset_size, | |
752 | section); | |
753 | if (mac_ptr == NULL) | |
754 | return; | |
755 | break; | |
dda83cd7 | 756 | } |
c90ec28a TT |
757 | DIAGNOSTIC_POP |
758 | } while (macinfo_type != 0); | |
759 | } | |
760 | ||
761 | void | |
976ca316 | 762 | dwarf_decode_macros (dwarf2_per_objfile *per_objfile, |
4f9c1eda TT |
763 | buildsym_compunit *builder, |
764 | const dwarf2_section_info *section, | |
5a0e026f | 765 | const struct line_header *lh, unsigned int offset_size, |
048fde1e | 766 | unsigned int offset, struct dwarf2_section_info *str_section, |
767 | struct dwarf2_section_info *str_offsets_section, | |
768 | ULONGEST str_offsets_base, int section_is_gnu) | |
c90ec28a TT |
769 | { |
770 | bfd *abfd; | |
771 | const gdb_byte *mac_ptr, *mac_end; | |
772 | struct macro_source_file *current_file = 0; | |
773 | enum dwarf_macro_record_type macinfo_type; | |
774 | const gdb_byte *opcode_definitions[256]; | |
775 | void **slot; | |
776 | ||
777 | abfd = section->get_bfd_owner (); | |
778 | ||
779 | /* First pass: Find the name of the base filename. | |
780 | This filename is needed in order to process all macros whose definition | |
781 | (or undefinition) comes from the command line. These macros are defined | |
782 | before the first DW_MACINFO_start_file entry, and yet still need to be | |
783 | associated to the base file. | |
784 | ||
785 | To determine the base file name, we scan the macro definitions until we | |
786 | reach the first DW_MACINFO_start_file entry. We then initialize | |
787 | CURRENT_FILE accordingly so that any macro definition found before the | |
788 | first DW_MACINFO_start_file can still be associated to the base file. */ | |
789 | ||
790 | mac_ptr = section->buffer + offset; | |
791 | mac_end = section->buffer + section->size; | |
792 | ||
793 | mac_ptr = dwarf_parse_macro_header (opcode_definitions, abfd, mac_ptr, | |
794 | &offset_size, section_is_gnu); | |
795 | if (mac_ptr == NULL) | |
796 | { | |
797 | /* We already issued a complaint. */ | |
798 | return; | |
799 | } | |
800 | ||
801 | do | |
802 | { | |
803 | /* Do we at least have room for a macinfo type byte? */ | |
804 | if (mac_ptr >= mac_end) | |
dda83cd7 | 805 | { |
c90ec28a TT |
806 | /* Complaint is printed during the second pass as GDB will probably |
807 | stop the first pass earlier upon finding | |
808 | DW_MACINFO_start_file. */ | |
809 | break; | |
dda83cd7 | 810 | } |
c90ec28a TT |
811 | |
812 | macinfo_type = (enum dwarf_macro_record_type) read_1_byte (abfd, mac_ptr); | |
813 | mac_ptr++; | |
814 | ||
815 | /* Note that we rely on the fact that the corresponding GNU and | |
816 | DWARF constants are the same. */ | |
817 | DIAGNOSTIC_PUSH | |
818 | DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES | |
819 | switch (macinfo_type) | |
dda83cd7 SM |
820 | { |
821 | /* A zero macinfo type indicates the end of the macro | |
822 | information. */ | |
823 | case 0: | |
c90ec28a TT |
824 | break; |
825 | ||
826 | case DW_MACRO_define: | |
827 | case DW_MACRO_undef: | |
828 | /* Only skip the data by MAC_PTR. */ | |
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 | break; | |
838 | ||
839 | case DW_MACRO_start_file: | |
840 | { | |
841 | unsigned int bytes_read; | |
842 | int line, file; | |
843 | ||
844 | line = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); | |
845 | mac_ptr += bytes_read; | |
846 | file = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); | |
847 | mac_ptr += bytes_read; | |
848 | ||
849 | current_file = macro_start_file (builder, file, line, | |
850 | current_file, lh); | |
851 | } | |
852 | break; | |
853 | ||
854 | case DW_MACRO_end_file: | |
855 | /* No data to skip by MAC_PTR. */ | |
856 | break; | |
857 | ||
858 | case DW_MACRO_define_strp: | |
859 | case DW_MACRO_undef_strp: | |
860 | case DW_MACRO_define_sup: | |
861 | case DW_MACRO_undef_sup: | |
862 | { | |
863 | unsigned int bytes_read; | |
864 | ||
865 | read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); | |
866 | mac_ptr += bytes_read; | |
867 | mac_ptr += offset_size; | |
868 | } | |
869 | break; | |
048fde1e | 870 | case DW_MACRO_define_strx: |
871 | case DW_MACRO_undef_strx: | |
872 | { | |
873 | unsigned int bytes_read; | |
874 | ||
875 | read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); | |
876 | mac_ptr += bytes_read; | |
877 | read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); | |
878 | mac_ptr += bytes_read; | |
879 | } | |
880 | break; | |
c90ec28a TT |
881 | |
882 | case DW_MACRO_import: | |
883 | case DW_MACRO_import_sup: | |
884 | /* Note that, according to the spec, a transparent include | |
885 | chain cannot call DW_MACRO_start_file. So, we can just | |
886 | skip this opcode. */ | |
887 | mac_ptr += offset_size; | |
888 | break; | |
889 | ||
890 | case DW_MACINFO_vendor_ext: | |
891 | /* Only skip the data by MAC_PTR. */ | |
892 | if (!section_is_gnu) | |
893 | { | |
894 | unsigned int bytes_read; | |
895 | ||
896 | read_unsigned_leb128 (abfd, mac_ptr, &bytes_read); | |
897 | mac_ptr += bytes_read; | |
898 | read_direct_string (abfd, mac_ptr, &bytes_read); | |
899 | mac_ptr += bytes_read; | |
900 | } | |
901 | /* FALLTHROUGH */ | |
902 | ||
903 | default: | |
904 | mac_ptr = skip_unknown_opcode (macinfo_type, opcode_definitions, | |
905 | mac_ptr, mac_end, abfd, offset_size, | |
906 | section); | |
907 | if (mac_ptr == NULL) | |
908 | return; | |
909 | break; | |
910 | } | |
911 | DIAGNOSTIC_POP | |
912 | } while (macinfo_type != 0 && current_file == NULL); | |
913 | ||
914 | /* Second pass: Process all entries. | |
915 | ||
916 | Use the AT_COMMAND_LINE flag to determine whether we are still processing | |
917 | command-line macro definitions/undefinitions. This flag is unset when we | |
918 | reach the first DW_MACINFO_start_file entry. */ | |
919 | ||
920 | htab_up include_hash (htab_create_alloc (1, htab_hash_pointer, | |
921 | htab_eq_pointer, | |
922 | NULL, xcalloc, xfree)); | |
923 | mac_ptr = section->buffer + offset; | |
924 | slot = htab_find_slot (include_hash.get (), mac_ptr, INSERT); | |
925 | *slot = (void *) mac_ptr; | |
976ca316 SM |
926 | dwarf_decode_macro_bytes (per_objfile, builder, abfd, mac_ptr, mac_end, |
927 | current_file, lh, section, section_is_gnu, 0, | |
048fde1e | 928 | offset_size, str_section, str_offsets_section, |
929 | str_offsets_base, include_hash.get ()); | |
c90ec28a | 930 | } |