gdb/dwarf2/macro.c

   1 /* Read DWARF macro information
   2
   3    Copyright (C) 1994-2022 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 }