1 /* Read DWARF macro information
3 Copyright (C) 1994-2021 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 (dwarf2_per_objfile
*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
,
430 struct dwarf2_section_info
*str_section
,
431 struct dwarf2_section_info
*str_offsets_section
,
432 ULONGEST str_offsets_base
,
435 struct objfile
*objfile
= per_objfile
->objfile
;
436 enum dwarf_macro_record_type macinfo_type
;
438 const gdb_byte
*opcode_definitions
[256];
440 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
441 &offset_size
, section_is_gnu
);
444 /* We already issued a complaint. */
448 /* Determines if GDB is still before first DW_MACINFO_start_file. If true
449 GDB is still reading the definitions from command line. First
450 DW_MACINFO_start_file will need to be ignored as it was already executed
451 to create CURRENT_FILE for the main source holding also the command line
452 definitions. On first met DW_MACINFO_start_file this flag is reset to
453 normally execute all the remaining DW_MACINFO_start_file macinfos. */
459 /* Do we at least have room for a macinfo type byte? */
460 if (mac_ptr
>= mac_end
)
462 section
->overflow_complaint ();
466 macinfo_type
= (enum dwarf_macro_record_type
) read_1_byte (abfd
, mac_ptr
);
469 /* Note that we rely on the fact that the corresponding GNU and
470 DWARF constants are the same. */
472 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
473 switch (macinfo_type
)
475 /* A zero macinfo type indicates the end of the macro
480 case DW_MACRO_define
:
482 case DW_MACRO_define_strp
:
483 case DW_MACRO_undef_strp
:
484 case DW_MACRO_define_sup
:
485 case DW_MACRO_undef_sup
:
487 unsigned int bytes_read
;
492 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
493 mac_ptr
+= bytes_read
;
495 if (macinfo_type
== DW_MACRO_define
496 || macinfo_type
== DW_MACRO_undef
)
498 body
= read_direct_string (abfd
, mac_ptr
, &bytes_read
);
499 mac_ptr
+= bytes_read
;
505 str_offset
= read_offset (abfd
, mac_ptr
, offset_size
);
506 mac_ptr
+= offset_size
;
508 if (macinfo_type
== DW_MACRO_define_sup
509 || macinfo_type
== DW_MACRO_undef_sup
512 dwz_file
*dwz
= dwarf2_get_dwz_file (per_objfile
->per_bfd
,
515 body
= dwz
->read_string (objfile
, str_offset
);
518 body
= per_objfile
->per_bfd
->str
.read_string (objfile
,
523 is_define
= (macinfo_type
== DW_MACRO_define
524 || macinfo_type
== DW_MACRO_define_strp
525 || macinfo_type
== DW_MACRO_define_sup
);
528 /* DWARF violation as no main source is present. */
529 complaint (_("debug info with no main source gives macro %s "
531 is_define
? _("definition") : _("undefinition"),
535 if ((line
== 0 && !at_commandline
)
536 || (line
!= 0 && at_commandline
))
537 complaint (_("debug info gives %s macro %s with %s line %d: %s"),
538 at_commandline
? _("command-line") : _("in-file"),
539 is_define
? _("definition") : _("undefinition"),
540 line
== 0 ? _("zero") : _("non-zero"), line
, body
);
544 /* Fedora's rpm-build's "debugedit" binary
545 corrupted .debug_macro sections.
548 https://bugzilla.redhat.com/show_bug.cgi?id=1708786 */
549 complaint (_("debug info gives %s invalid macro %s "
550 "without body (corrupted?) at line %d "
552 at_commandline
? _("command-line") : _("in-file"),
553 is_define
? _("definition") : _("undefinition"),
554 line
, current_file
->filename
);
557 parse_macro_definition (current_file
, line
, body
);
560 gdb_assert (macinfo_type
== DW_MACRO_undef
561 || macinfo_type
== DW_MACRO_undef_strp
562 || macinfo_type
== DW_MACRO_undef_sup
);
563 macro_undef (current_file
, line
, body
);
568 case DW_MACRO_define_strx
:
569 case DW_MACRO_undef_strx
:
571 unsigned int bytes_read
;
573 int line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
574 mac_ptr
+= bytes_read
;
575 int offset_index
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
576 mac_ptr
+= bytes_read
;
578 str_offsets_section
->read (objfile
);
579 const gdb_byte
*info_ptr
= (str_offsets_section
->buffer
581 + offset_index
* offset_size
);
583 const char *macinfo_str
= (macinfo_type
== DW_MACRO_define_strx
?
584 "DW_MACRO_define_strx" : "DW_MACRO_undef_strx");
586 if (str_offsets_base
+ offset_index
* offset_size
587 >= str_offsets_section
->size
)
589 complaint (_("%s pointing outside of .debug_str_offsets section "
590 "[in module %s]"), macinfo_str
, objfile_name (objfile
));
594 ULONGEST str_offset
= read_offset (abfd
, info_ptr
, offset_size
);
596 const char *body
= str_section
->read_string (objfile
, str_offset
,
598 if (current_file
== nullptr)
600 /* DWARF violation as no main source is present. */
601 complaint (_("debug info with no main source gives macro %s "
603 macinfo_type
== DW_MACRO_define_strx
? _("definition")
604 : _("undefinition"), line
, body
);
608 if (macinfo_type
== DW_MACRO_define_strx
)
609 parse_macro_definition (current_file
, line
, body
);
611 macro_undef (current_file
, line
, body
);
615 case DW_MACRO_start_file
:
617 unsigned int bytes_read
;
620 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
621 mac_ptr
+= bytes_read
;
622 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
623 mac_ptr
+= bytes_read
;
625 if ((line
== 0 && !at_commandline
)
626 || (line
!= 0 && at_commandline
))
627 complaint (_("debug info gives source %d included "
628 "from %s at %s line %d"),
629 file
, at_commandline
? _("command-line") : _("file"),
630 line
== 0 ? _("zero") : _("non-zero"), line
);
634 /* This DW_MACRO_start_file was executed in the
639 current_file
= macro_start_file (builder
, file
, line
,
644 case DW_MACRO_end_file
:
646 complaint (_("macro debug info has an unmatched "
647 "`close_file' directive"));
650 current_file
= current_file
->included_by
;
653 enum dwarf_macro_record_type next_type
;
655 /* GCC circa March 2002 doesn't produce the zero
656 type byte marking the end of the compilation
657 unit. Complain if it's not there, but exit no
660 /* Do we at least have room for a macinfo type byte? */
661 if (mac_ptr
>= mac_end
)
663 section
->overflow_complaint ();
667 /* We don't increment mac_ptr here, so this is just
670 = (enum dwarf_macro_record_type
) read_1_byte (abfd
,
673 complaint (_("no terminating 0-type entry for "
674 "macros in `.debug_macinfo' section"));
681 case DW_MACRO_import
:
682 case DW_MACRO_import_sup
:
686 bfd
*include_bfd
= abfd
;
687 const struct dwarf2_section_info
*include_section
= section
;
688 const gdb_byte
*include_mac_end
= mac_end
;
689 int is_dwz
= section_is_dwz
;
690 const gdb_byte
*new_mac_ptr
;
692 offset
= read_offset (abfd
, mac_ptr
, offset_size
);
693 mac_ptr
+= offset_size
;
695 if (macinfo_type
== DW_MACRO_import_sup
)
697 dwz_file
*dwz
= dwarf2_get_dwz_file (per_objfile
->per_bfd
,
700 dwz
->macro
.read (objfile
);
702 include_section
= &dwz
->macro
;
703 include_bfd
= include_section
->get_bfd_owner ();
704 include_mac_end
= dwz
->macro
.buffer
+ dwz
->macro
.size
;
708 new_mac_ptr
= include_section
->buffer
+ offset
;
709 slot
= htab_find_slot (include_hash
, new_mac_ptr
, INSERT
);
713 /* This has actually happened; see
714 http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
715 complaint (_("recursive DW_MACRO_import in "
716 ".debug_macro section"));
720 *slot
= (void *) new_mac_ptr
;
722 dwarf_decode_macro_bytes (per_objfile
, builder
, include_bfd
,
723 new_mac_ptr
, include_mac_end
,
724 current_file
, lh
, section
,
725 section_is_gnu
, is_dwz
, offset_size
,
726 str_section
, str_offsets_section
,
727 str_offsets_base
, include_hash
);
729 htab_remove_elt (include_hash
, (void *) new_mac_ptr
);
734 case DW_MACINFO_vendor_ext
:
737 unsigned int bytes_read
;
739 /* This reads the constant, but since we don't recognize
740 any vendor extensions, we ignore it. */
741 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
742 mac_ptr
+= bytes_read
;
743 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
744 mac_ptr
+= bytes_read
;
746 /* We don't recognize any vendor extensions. */
752 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
753 mac_ptr
, mac_end
, abfd
, offset_size
,
760 } while (macinfo_type
!= 0);
764 dwarf_decode_macros (dwarf2_per_objfile
*per_objfile
,
765 buildsym_compunit
*builder
,
766 const dwarf2_section_info
*section
,
767 const struct line_header
*lh
, unsigned int offset_size
,
768 unsigned int offset
, struct dwarf2_section_info
*str_section
,
769 struct dwarf2_section_info
*str_offsets_section
,
770 ULONGEST str_offsets_base
, int section_is_gnu
)
773 const gdb_byte
*mac_ptr
, *mac_end
;
774 struct macro_source_file
*current_file
= 0;
775 enum dwarf_macro_record_type macinfo_type
;
776 const gdb_byte
*opcode_definitions
[256];
779 abfd
= section
->get_bfd_owner ();
781 /* First pass: Find the name of the base filename.
782 This filename is needed in order to process all macros whose definition
783 (or undefinition) comes from the command line. These macros are defined
784 before the first DW_MACINFO_start_file entry, and yet still need to be
785 associated to the base file.
787 To determine the base file name, we scan the macro definitions until we
788 reach the first DW_MACINFO_start_file entry. We then initialize
789 CURRENT_FILE accordingly so that any macro definition found before the
790 first DW_MACINFO_start_file can still be associated to the base file. */
792 mac_ptr
= section
->buffer
+ offset
;
793 mac_end
= section
->buffer
+ section
->size
;
795 mac_ptr
= dwarf_parse_macro_header (opcode_definitions
, abfd
, mac_ptr
,
796 &offset_size
, section_is_gnu
);
799 /* We already issued a complaint. */
805 /* Do we at least have room for a macinfo type byte? */
806 if (mac_ptr
>= mac_end
)
808 /* Complaint is printed during the second pass as GDB will probably
809 stop the first pass earlier upon finding
810 DW_MACINFO_start_file. */
814 macinfo_type
= (enum dwarf_macro_record_type
) read_1_byte (abfd
, mac_ptr
);
817 /* Note that we rely on the fact that the corresponding GNU and
818 DWARF constants are the same. */
820 DIAGNOSTIC_IGNORE_SWITCH_DIFFERENT_ENUM_TYPES
821 switch (macinfo_type
)
823 /* A zero macinfo type indicates the end of the macro
828 case DW_MACRO_define
:
830 /* Only skip the data by MAC_PTR. */
832 unsigned int bytes_read
;
834 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
835 mac_ptr
+= bytes_read
;
836 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
837 mac_ptr
+= bytes_read
;
841 case DW_MACRO_start_file
:
843 unsigned int bytes_read
;
846 line
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
847 mac_ptr
+= bytes_read
;
848 file
= read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
849 mac_ptr
+= bytes_read
;
851 current_file
= macro_start_file (builder
, file
, line
,
856 case DW_MACRO_end_file
:
857 /* No data to skip by MAC_PTR. */
860 case DW_MACRO_define_strp
:
861 case DW_MACRO_undef_strp
:
862 case DW_MACRO_define_sup
:
863 case DW_MACRO_undef_sup
:
865 unsigned int bytes_read
;
867 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
868 mac_ptr
+= bytes_read
;
869 mac_ptr
+= offset_size
;
872 case DW_MACRO_define_strx
:
873 case DW_MACRO_undef_strx
:
875 unsigned int bytes_read
;
877 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
878 mac_ptr
+= bytes_read
;
879 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
880 mac_ptr
+= bytes_read
;
884 case DW_MACRO_import
:
885 case DW_MACRO_import_sup
:
886 /* Note that, according to the spec, a transparent include
887 chain cannot call DW_MACRO_start_file. So, we can just
889 mac_ptr
+= offset_size
;
892 case DW_MACINFO_vendor_ext
:
893 /* Only skip the data by MAC_PTR. */
896 unsigned int bytes_read
;
898 read_unsigned_leb128 (abfd
, mac_ptr
, &bytes_read
);
899 mac_ptr
+= bytes_read
;
900 read_direct_string (abfd
, mac_ptr
, &bytes_read
);
901 mac_ptr
+= bytes_read
;
906 mac_ptr
= skip_unknown_opcode (macinfo_type
, opcode_definitions
,
907 mac_ptr
, mac_end
, abfd
, offset_size
,
914 } while (macinfo_type
!= 0 && current_file
== NULL
);
916 /* Second pass: Process all entries.
918 Use the AT_COMMAND_LINE flag to determine whether we are still processing
919 command-line macro definitions/undefinitions. This flag is unset when we
920 reach the first DW_MACINFO_start_file entry. */
922 htab_up
include_hash (htab_create_alloc (1, htab_hash_pointer
,
924 NULL
, xcalloc
, xfree
));
925 mac_ptr
= section
->buffer
+ offset
;
926 slot
= htab_find_slot (include_hash
.get (), mac_ptr
, INSERT
);
927 *slot
= (void *) mac_ptr
;
928 dwarf_decode_macro_bytes (per_objfile
, builder
, abfd
, mac_ptr
, mac_end
,
929 current_file
, lh
, section
, section_is_gnu
, 0,
930 offset_size
, str_section
, str_offsets_section
,
931 str_offsets_base
, include_hash
.get ());