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