1 /* Read DWARF macro information
3 Copyright (C) 1994-2020 Free Software Foundation, Inc.
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
12 This file is part of GDB.
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.
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.
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/>. */
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"
37 #include "complaints.h"
40 dwarf2_macro_malformed_definition_complaint (const char *arg1
)
42 complaint (_("macro debug info contains a "
43 "malformed macro definition:\n`%s'"),
47 static struct macro_source_file
*
48 macro_start_file (buildsym_compunit
*builder
,
50 struct macro_source_file
*current_file
,
51 const struct line_header
*lh
)
53 /* File name relative to the compilation directory of this source file. */
54 gdb::unique_xmalloc_ptr
<char> file_name
= lh
->file_file_name (file
);
58 /* Note: We don't create a macro table for this compilation unit
59 at all until we actually get a filename. */
60 struct macro_table
*macro_table
= builder
->get_macro_table ();
62 /* If we have no current file, then this must be the start_file
63 directive for the compilation unit's main source file. */
64 current_file
= macro_set_main (macro_table
, file_name
.get ());
65 macro_define_special (macro_table
);
68 current_file
= macro_include (current_file
, line
, file_name
.get ());
74 consume_improper_spaces (const char *p
, const char *body
)
78 complaint (_("macro definition contains spaces "
79 "in formal argument list:\n`%s'"),
91 parse_macro_definition (struct macro_source_file
*file
, int line
,
96 /* The body string takes one of two forms. For object-like macro
97 definitions, it should be:
99 <macro name> " " <definition>
101 For function-like macro definitions, it should be:
103 <macro name> "() " <definition>
105 <macro name> "(" <arg name> ( "," <arg name> ) * ") " <definition>
107 Spaces may appear only where explicitly indicated, and in the
110 The Dwarf 2 spec says that an object-like macro's name is always
111 followed by a space, but versions of GCC around March 2002 omit
112 the space when the macro's definition is the empty string.
114 The Dwarf 2 spec says that there should be no spaces between the
115 formal arguments in a function-like macro's formal argument list,
116 but versions of GCC around March 2002 include spaces after the
120 /* Find the extent of the macro name. The macro name is terminated
121 by either a space or null character (for an object-like macro) or
122 an opening paren (for a function-like macro). */
123 for (p
= body
; *p
; p
++)
124 if (*p
== ' ' || *p
== '(')
127 if (*p
== ' ' || *p
== '\0')
129 /* It's an object-like macro. */
130 int name_len
= p
- body
;
131 std::string
name (body
, name_len
);
132 const char *replacement
;
135 replacement
= body
+ name_len
+ 1;
138 dwarf2_macro_malformed_definition_complaint (body
);
139 replacement
= body
+ name_len
;
142 macro_define_object (file
, line
, name
.c_str (), replacement
);
146 /* It's a function-like macro. */
147 std::string
name (body
, p
- body
);
150 char **argv
= XNEWVEC (char *, argv_size
);
154 p
= consume_improper_spaces (p
, body
);
156 /* Parse the formal argument list. */
157 while (*p
&& *p
!= ')')
159 /* Find the extent of the current argument name. */
160 const char *arg_start
= p
;
162 while (*p
&& *p
!= ',' && *p
!= ')' && *p
!= ' ')
165 if (! *p
|| p
== arg_start
)
166 dwarf2_macro_malformed_definition_complaint (body
);
169 /* Make sure argv has room for the new argument. */
170 if (argc
>= argv_size
)
173 argv
= XRESIZEVEC (char *, argv
, argv_size
);
176 argv
[argc
++] = savestring (arg_start
, p
- arg_start
);
179 p
= consume_improper_spaces (p
, body
);
181 /* Consume the comma, if present. */
186 p
= consume_improper_spaces (p
, body
);
195 /* Perfectly formed definition, no complaints. */
196 macro_define_function (file
, line
, name
.c_str (),
197 argc
, (const char **) argv
,
201 /* Complain, but do define it. */
202 dwarf2_macro_malformed_definition_complaint (body
);
203 macro_define_function (file
, line
, name
.c_str (),
204 argc
, (const char **) argv
,
209 dwarf2_macro_malformed_definition_complaint (body
);
213 dwarf2_macro_malformed_definition_complaint (body
);
218 for (i
= 0; i
< argc
; i
++)
224 dwarf2_macro_malformed_definition_complaint (body
);
227 /* Skip some bytes from BYTES according to the form given in FORM.
228 Returns the new pointer. */
230 static const gdb_byte
*
231 skip_form_bytes (bfd
*abfd
, const gdb_byte
*bytes
, const gdb_byte
*buffer_end
,
232 enum dwarf_form form
,
233 unsigned int offset_size
,
234 const struct dwarf2_section_info
*section
)
236 unsigned int bytes_read
;
262 read_direct_string (abfd
, bytes
, &bytes_read
);
266 case DW_FORM_sec_offset
:
268 case DW_FORM_GNU_strp_alt
:
269 bytes
+= offset_size
;
273 bytes
+= read_unsigned_leb128 (abfd
, bytes
, &bytes_read
);
278 bytes
+= 1 + read_1_byte (abfd
, bytes
);
281 bytes
+= 2 + read_2_bytes (abfd
, bytes
);
284 bytes
+= 4 + read_4_bytes (abfd
, bytes
);
291 case DW_FORM_GNU_addr_index
:
292 case DW_FORM_GNU_str_index
:
293 bytes
= gdb_skip_leb128 (bytes
, buffer_end
);
296 section
->overflow_complaint ();
301 case DW_FORM_implicit_const
:
306 complaint (_("invalid form 0x%x in `%s'"),
307 form
, section
->get_name ());
315 /* A helper for dwarf_decode_macros that handles skipping an unknown
316 opcode. Returns an updated pointer to the macro data buffer; or,
317 on error, issues a complaint and returns NULL. */
319 static const gdb_byte
*
320 skip_unknown_opcode (unsigned int opcode
,
321 const gdb_byte
**opcode_definitions
,
322 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
324 unsigned int offset_size
,
325 const struct dwarf2_section_info
*section
)
327 unsigned int bytes_read
, i
;
329 const gdb_byte
*defn
;
331 if (opcode_definitions
[opcode
] == NULL
)
333 complaint (_("unrecognized DW_MACFINO opcode 0x%x"),
338 defn
= opcode_definitions
[opcode
];
339 arg
= read_unsigned_leb128 (abfd
, defn
, &bytes_read
);
342 for (i
= 0; i
< arg
; ++i
)
344 mac_ptr
= skip_form_bytes (abfd
, mac_ptr
, mac_end
,
345 (enum dwarf_form
) defn
[i
], offset_size
,
349 /* skip_form_bytes already issued the complaint. */
357 /* A helper function which parses the header of a macro section.
358 If the macro section is the extended (for now called "GNU") type,
359 then this updates *OFFSET_SIZE. Returns a pointer to just after
360 the header, or issues a complaint and returns NULL on error. */
362 static const gdb_byte
*
363 dwarf_parse_macro_header (const gdb_byte
**opcode_definitions
,
365 const gdb_byte
*mac_ptr
,
366 unsigned int *offset_size
,
369 memset (opcode_definitions
, 0, 256 * sizeof (gdb_byte
*));
373 unsigned int version
, flags
;
375 version
= read_2_bytes (abfd
, mac_ptr
);
376 if (version
!= 4 && version
!= 5)
378 complaint (_("unrecognized version `%d' in .debug_macro section"),
384 flags
= read_1_byte (abfd
, mac_ptr
);
386 *offset_size
= (flags
& 1) ? 8 : 4;
388 if ((flags
& 2) != 0)
389 /* We don't need the line table offset. */
390 mac_ptr
+= *offset_size
;
392 /* Vendor opcode descriptions. */
393 if ((flags
& 4) != 0)
395 unsigned int i
, count
;
397 count
= read_1_byte (abfd
, mac_ptr
);
399 for (i
= 0; i
< count
; ++i
)
401 unsigned int opcode
, bytes_read
;
404 opcode
= read_1_byte (abfd
, mac_ptr
);
406 opcode_definitions
[opcode
] = mac_ptr
;
407 arg
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
408 mac_ptr
+= bytes_read
;
417 /* A helper for dwarf_decode_macros that handles the GNU extensions,
418 including DW_MACRO_import. */
421 dwarf_decode_macro_bytes (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
422 buildsym_compunit
*builder
,
424 const gdb_byte
*mac_ptr
, const gdb_byte
*mac_end
,
425 struct macro_source_file
*current_file
,
426 const struct line_header
*lh
,
427 const struct dwarf2_section_info
*section
,
428 int section_is_gnu
, int section_is_dwz
,
429 unsigned int offset_size
,
432 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
433 enum dwarf_macro_record_type macinfo_type
;
435 const gdb_byte
*opcode_definitions
[256];
437 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
438 &offset_size
, section_is_gnu
);
441 /* We already issued a complaint. */
445 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
446 GDB is still reading the definitions from command line. First
447 DW_MACINFO_start_file will need to be ignored as it was already executed
448 to create CURRENT_FILE for the main source holding also the command line
449 definitions. On first met DW_MACINFO_start_file this flag is reset to
450 normally execute all the remaining DW_MACINFO_start_file macinfos. */
456 /* Do we at least have room for a macinfo type byte? */
457 if (mac_ptr
>= mac_end
)
459 section
->overflow_complaint ();
463 macinfo_type
= (enum dwarf_macro_record_type
) read_1_byte (abfd
, mac_ptr
);
466 /* Note that we rely on the fact that the corresponding GNU and
467 DWARF constants are the same. */
469 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
470 switch (macinfo_type
)
472 /* A zero macinfo type indicates the end of the macro
477 case DW_MACRO_define
:
479 case DW_MACRO_define_strp
:
480 case DW_MACRO_undef_strp
:
481 case DW_MACRO_define_sup
:
482 case DW_MACRO_undef_sup
:
484 unsigned int bytes_read
;
489 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
490 mac_ptr
+= bytes_read
;
492 if (macinfo_type
== DW_MACRO_define
493 || macinfo_type
== DW_MACRO_undef
)
495 body
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
496 mac_ptr
+= bytes_read
;
502 str_offset
= read_offset (abfd
, mac_ptr
, offset_size
);
503 mac_ptr
+= offset_size
;
505 if (macinfo_type
== DW_MACRO_define_sup
506 || macinfo_type
== DW_MACRO_undef_sup
510 = dwarf2_get_dwz_file (dwarf2_per_objfile
);
512 body
= dwz
->read_string (objfile
, str_offset
);
515 body
= dwarf2_per_objfile
->str
.read_string (objfile
,
520 is_define
= (macinfo_type
== DW_MACRO_define
521 || macinfo_type
== DW_MACRO_define_strp
522 || macinfo_type
== DW_MACRO_define_sup
);
525 /* DWARF violation as no main source is present. */
526 complaint (_("debug info with no main source gives macro %s "
528 is_define
? _("definition") : _("undefinition"),
532 if ((line
== 0 && !at_commandline
)
533 || (line
!= 0 && at_commandline
))
534 complaint (_("debug info gives %s macro %s with %s line %d: %s"),
535 at_commandline
? _("command-line") : _("in-file"),
536 is_define
? _("definition") : _("undefinition"),
537 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
541 /* Fedora's rpm-build's "debugedit" binary
542 corrupted .debug_macro sections.
545 https://bugzilla.redhat.com/show_bug.cgi?id=1708786 */
546 complaint (_("debug info gives %s invalid macro %s "
547 "without body (corrupted?) at line %d "
549 at_commandline
? _("command-line") : _("in-file"),
550 is_define
? _("definition") : _("undefinition"),
551 line
, current_file
->filename
);
554 parse_macro_definition (current_file
, line
, body
);
557 gdb_assert (macinfo_type
== DW_MACRO_undef
558 || macinfo_type
== DW_MACRO_undef_strp
559 || macinfo_type
== DW_MACRO_undef_sup
);
560 macro_undef (current_file
, line
, body
);
565 case DW_MACRO_start_file
:
567 unsigned int bytes_read
;
570 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
571 mac_ptr
+= bytes_read
;
572 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
573 mac_ptr
+= bytes_read
;
575 if ((line
== 0 && !at_commandline
)
576 || (line
!= 0 && at_commandline
))
577 complaint (_("debug info gives source %d included "
578 "from %s at %s line %d"),
579 file
, at_commandline
? _("command-line") : _("file"),
580 line
== 0 ? _("zero") : _("non-zero"), line
);
584 /* This DW_MACRO_start_file was executed in the
589 current_file
= macro_start_file (builder
, file
, line
,
594 case DW_MACRO_end_file
:
596 complaint (_("macro debug info has an unmatched "
597 "`close_file' directive"));
600 current_file
= current_file
->included_by
;
603 enum dwarf_macro_record_type next_type
;
605 /* GCC circa March 2002 doesn't produce the zero
606 type byte marking the end of the compilation
607 unit. Complain if it's not there, but exit no
610 /* Do we at least have room for a macinfo type byte? */
611 if (mac_ptr
>= mac_end
)
613 section
->overflow_complaint ();
617 /* We don't increment mac_ptr here, so this is just
620 = (enum dwarf_macro_record_type
) read_1_byte (abfd
,
623 complaint (_("no terminating 0-type entry for "
624 "macros in `.debug_macinfo' section"));
631 case DW_MACRO_import
:
632 case DW_MACRO_import_sup
:
636 bfd
*include_bfd
= abfd
;
637 const struct dwarf2_section_info
*include_section
= section
;
638 const gdb_byte
*include_mac_end
= mac_end
;
639 int is_dwz
= section_is_dwz
;
640 const gdb_byte
*new_mac_ptr
;
642 offset
= read_offset (abfd
, mac_ptr
, offset_size
);
643 mac_ptr
+= offset_size
;
645 if (macinfo_type
== DW_MACRO_import_sup
)
647 struct dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
649 dwz
->macro
.read (objfile
);
651 include_section
= &dwz
->macro
;
652 include_bfd
= include_section
->get_bfd_owner ();
653 include_mac_end
= dwz
->macro
.buffer
+ dwz
->macro
.size
;
657 new_mac_ptr
= include_section
->buffer
+ offset
;
658 slot
= htab_find_slot (include_hash
, new_mac_ptr
, INSERT
);
662 /* This has actually happened; see
663 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
664 complaint (_("recursive DW_MACRO_import in "
665 ".debug_macro section"));
669 *slot
= (void *) new_mac_ptr
;
671 dwarf_decode_macro_bytes (dwarf2_per_objfile
, builder
,
672 include_bfd
, new_mac_ptr
,
673 include_mac_end
, current_file
, lh
,
674 section
, section_is_gnu
, is_dwz
,
675 offset_size
, include_hash
);
677 htab_remove_elt (include_hash
, (void *) new_mac_ptr
);
682 case DW_MACINFO_vendor_ext
:
685 unsigned int bytes_read
;
687 /* This reads the constant, but since we don't recognize
688 any vendor extensions, we ignore it. */
689 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
690 mac_ptr
+= bytes_read
;
691 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
692 mac_ptr
+= bytes_read
;
694 /* We don't recognize any vendor extensions. */
700 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
701 mac_ptr
, mac_end
, abfd
, offset_size
,
708 } while (macinfo_type
!= 0);
712 dwarf_decode_macros (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
713 buildsym_compunit
*builder
,
714 const dwarf2_section_info
*section
,
715 const struct line_header
*lh
, unsigned int offset_size
,
716 unsigned int offset
, int section_is_gnu
)
719 const gdb_byte
*mac_ptr
, *mac_end
;
720 struct macro_source_file
*current_file
= 0;
721 enum dwarf_macro_record_type macinfo_type
;
722 const gdb_byte
*opcode_definitions
[256];
725 abfd
= section
->get_bfd_owner ();
727 /* First pass: Find the name of the base filename.
728 This filename is needed in order to process all macros whose definition
729 (or undefinition) comes from the command line. These macros are defined
730 before the first DW_MACINFO_start_file entry, and yet still need to be
731 associated to the base file.
733 To determine the base file name, we scan the macro definitions until we
734 reach the first DW_MACINFO_start_file entry. We then initialize
735 CURRENT_FILE accordingly so that any macro definition found before the
736 first DW_MACINFO_start_file can still be associated to the base file. */
738 mac_ptr
= section
->buffer
+ offset
;
739 mac_end
= section
->buffer
+ section
->size
;
741 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
742 &offset_size
, section_is_gnu
);
745 /* We already issued a complaint. */
751 /* Do we at least have room for a macinfo type byte? */
752 if (mac_ptr
>= mac_end
)
754 /* Complaint is printed during the second pass as GDB will probably
755 stop the first pass earlier upon finding
756 DW_MACINFO_start_file. */
760 macinfo_type
= (enum dwarf_macro_record_type
) read_1_byte (abfd
, mac_ptr
);
763 /* Note that we rely on the fact that the corresponding GNU and
764 DWARF constants are the same. */
766 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
767 switch (macinfo_type
)
769 /* A zero macinfo type indicates the end of the macro
774 case DW_MACRO_define
:
776 /* Only skip the data by MAC_PTR. */
778 unsigned int bytes_read
;
780 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
781 mac_ptr
+= bytes_read
;
782 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
783 mac_ptr
+= bytes_read
;
787 case DW_MACRO_start_file
:
789 unsigned int bytes_read
;
792 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
793 mac_ptr
+= bytes_read
;
794 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
795 mac_ptr
+= bytes_read
;
797 current_file
= macro_start_file (builder
, file
, line
,
802 case DW_MACRO_end_file
:
803 /* No data to skip by MAC_PTR. */
806 case DW_MACRO_define_strp
:
807 case DW_MACRO_undef_strp
:
808 case DW_MACRO_define_sup
:
809 case DW_MACRO_undef_sup
:
811 unsigned int bytes_read
;
813 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
814 mac_ptr
+= bytes_read
;
815 mac_ptr
+= offset_size
;
819 case DW_MACRO_import
:
820 case DW_MACRO_import_sup
:
821 /* Note that, according to the spec, a transparent include
822 chain cannot call DW_MACRO_start_file. So, we can just
824 mac_ptr
+= offset_size
;
827 case DW_MACINFO_vendor_ext
:
828 /* Only skip the data by MAC_PTR. */
831 unsigned int bytes_read
;
833 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
834 mac_ptr
+= bytes_read
;
835 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
836 mac_ptr
+= bytes_read
;
841 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
842 mac_ptr
, mac_end
, abfd
, offset_size
,
849 } while (macinfo_type
!= 0 && current_file
== NULL
);
851 /* Second pass: Process all entries.
853 Use the AT_COMMAND_LINE flag to determine whether we are still processing
854 command-line macro definitions/undefinitions. This flag is unset when we
855 reach the first DW_MACINFO_start_file entry. */
857 htab_up
include_hash (htab_create_alloc (1, htab_hash_pointer
,
859 NULL
, xcalloc
, xfree
));
860 mac_ptr
= section
->buffer
+ offset
;
861 slot
= htab_find_slot (include_hash
.get (), mac_ptr
, INSERT
);
862 *slot
= (void *) mac_ptr
;
863 dwarf_decode_macro_bytes (dwarf2_per_objfile
, builder
,
864 abfd
, mac_ptr
, mac_end
,
865 current_file
, lh
, section
,
866 section_is_gnu
, 0, offset_size
,
867 include_hash
.get ());