]> Git Repo - binutils.git/blob - gdb/dwarf2/macro.c
Automatic date update in version.in
[binutils.git] / 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 ([email protected]), 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 }
This page took 0.082069 seconds and 4 git commands to generate.