1 /* DWARF index writing support for GDB.
3 Copyright (C) 1994-2020 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "dwarf2/index-write.h"
25 #include "cli/cli-decode.h"
26 #include "gdbsupport/byte-vector.h"
27 #include "gdbsupport/filestuff.h"
28 #include "gdbsupport/gdb_unlinker.h"
29 #include "gdbsupport/pathstuff.h"
30 #include "gdbsupport/scoped_fd.h"
31 #include "complaints.h"
32 #include "dwarf2/index-common.h"
34 #include "dwarf2/read.h"
35 #include "dwarf2/dwz.h"
36 #include "gdb/gdb-index.h"
45 #include <unordered_map>
46 #include <unordered_set>
48 /* Ensure only legit values are used. */
49 #define DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE(cu_index, value) \
51 gdb_assert ((unsigned int) (value) <= 1); \
52 GDB_INDEX_SYMBOL_STATIC_SET_VALUE((cu_index), (value)); \
55 /* Ensure only legit values are used. */
56 #define DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE(cu_index, value) \
58 gdb_assert ((value) >= GDB_INDEX_SYMBOL_KIND_TYPE \
59 && (value) <= GDB_INDEX_SYMBOL_KIND_OTHER); \
60 GDB_INDEX_SYMBOL_KIND_SET_VALUE((cu_index), (value)); \
63 /* Ensure we don't use more than the allotted number of bits for the CU. */
64 #define DW2_GDB_INDEX_CU_SET_VALUE(cu_index, value) \
66 gdb_assert (((value) & ~GDB_INDEX_CU_MASK) == 0); \
67 GDB_INDEX_CU_SET_VALUE((cu_index), (value)); \
70 /* The "save gdb-index" command. */
72 /* Write SIZE bytes from the buffer pointed to by DATA to FILE, with
76 file_write (FILE *file
, const void *data
, size_t size
)
78 if (fwrite (data
, 1, size
, file
) != size
)
79 error (_("couldn't data write to file"));
82 /* Write the contents of VEC to FILE, with error checking. */
84 template<typename Elem
, typename Alloc
>
86 file_write (FILE *file
, const std::vector
<Elem
, Alloc
> &vec
)
89 file_write (file
, vec
.data (), vec
.size () * sizeof (vec
[0]));
92 /* In-memory buffer to prepare data to be written later to a file. */
96 /* Copy DATA to the end of the buffer. */
98 void append_data (const T
&data
)
100 std::copy (reinterpret_cast<const gdb_byte
*> (&data
),
101 reinterpret_cast<const gdb_byte
*> (&data
+ 1),
102 grow (sizeof (data
)));
105 /* Copy CSTR (a zero-terminated string) to the end of buffer. The
106 terminating zero is appended too. */
107 void append_cstr0 (const char *cstr
)
109 const size_t size
= strlen (cstr
) + 1;
110 std::copy (cstr
, cstr
+ size
, grow (size
));
113 /* Store INPUT as ULEB128 to the end of buffer. */
114 void append_unsigned_leb128 (ULONGEST input
)
118 gdb_byte output
= input
& 0x7f;
122 append_data (output
);
128 /* Accept a host-format integer in VAL and append it to the buffer
129 as a target-format integer which is LEN bytes long. */
130 void append_uint (size_t len
, bfd_endian byte_order
, ULONGEST val
)
132 ::store_unsigned_integer (grow (len
), len
, byte_order
, val
);
135 /* Return the size of the buffer. */
138 return m_vec
.size ();
141 /* Return true iff the buffer is empty. */
144 return m_vec
.empty ();
147 /* Write the buffer to FILE. */
148 void file_write (FILE *file
) const
150 ::file_write (file
, m_vec
);
154 /* Grow SIZE bytes at the end of the buffer. Returns a pointer to
155 the start of the new block. */
156 gdb_byte
*grow (size_t size
)
158 m_vec
.resize (m_vec
.size () + size
);
159 return &*(m_vec
.end () - size
);
162 gdb::byte_vector m_vec
;
165 /* An entry in the symbol table. */
166 struct symtab_index_entry
168 /* The name of the symbol. */
170 /* The offset of the name in the constant pool. */
171 offset_type index_offset
;
172 /* A sorted vector of the indices of all the CUs that hold an object
174 std::vector
<offset_type
> cu_indices
;
177 /* The symbol table. This is a power-of-2-sized hash table. */
185 offset_type n_elements
= 0;
186 std::vector
<symtab_index_entry
> data
;
189 /* Find a slot in SYMTAB for the symbol NAME. Returns a reference to
192 Function is used only during write_hash_table so no index format backward
193 compatibility is needed. */
195 static symtab_index_entry
&
196 find_slot (struct mapped_symtab
*symtab
, const char *name
)
198 offset_type index
, step
, hash
= mapped_index_string_hash (INT_MAX
, name
);
200 index
= hash
& (symtab
->data
.size () - 1);
201 step
= ((hash
* 17) & (symtab
->data
.size () - 1)) | 1;
205 if (symtab
->data
[index
].name
== NULL
206 || strcmp (name
, symtab
->data
[index
].name
) == 0)
207 return symtab
->data
[index
];
208 index
= (index
+ step
) & (symtab
->data
.size () - 1);
212 /* Expand SYMTAB's hash table. */
215 hash_expand (struct mapped_symtab
*symtab
)
217 auto old_entries
= std::move (symtab
->data
);
219 symtab
->data
.clear ();
220 symtab
->data
.resize (old_entries
.size () * 2);
222 for (auto &it
: old_entries
)
225 auto &ref
= find_slot (symtab
, it
.name
);
226 ref
= std::move (it
);
230 /* Add an entry to SYMTAB. NAME is the name of the symbol.
231 CU_INDEX is the index of the CU in which the symbol appears.
232 IS_STATIC is one if the symbol is static, otherwise zero (global). */
235 add_index_entry (struct mapped_symtab
*symtab
, const char *name
,
236 int is_static
, gdb_index_symbol_kind kind
,
237 offset_type cu_index
)
239 offset_type cu_index_and_attrs
;
241 ++symtab
->n_elements
;
242 if (4 * symtab
->n_elements
/ 3 >= symtab
->data
.size ())
243 hash_expand (symtab
);
245 symtab_index_entry
&slot
= find_slot (symtab
, name
);
246 if (slot
.name
== NULL
)
249 /* index_offset is set later. */
252 cu_index_and_attrs
= 0;
253 DW2_GDB_INDEX_CU_SET_VALUE (cu_index_and_attrs
, cu_index
);
254 DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE (cu_index_and_attrs
, is_static
);
255 DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE (cu_index_and_attrs
, kind
);
257 /* We don't want to record an index value twice as we want to avoid the
259 We process all global symbols and then all static symbols
260 (which would allow us to avoid the duplication by only having to check
261 the last entry pushed), but a symbol could have multiple kinds in one CU.
262 To keep things simple we don't worry about the duplication here and
263 sort and uniquify the list after we've processed all symbols. */
264 slot
.cu_indices
.push_back (cu_index_and_attrs
);
267 /* Sort and remove duplicates of all symbols' cu_indices lists. */
270 uniquify_cu_indices (struct mapped_symtab
*symtab
)
272 for (auto &entry
: symtab
->data
)
274 if (entry
.name
!= NULL
&& !entry
.cu_indices
.empty ())
276 auto &cu_indices
= entry
.cu_indices
;
277 std::sort (cu_indices
.begin (), cu_indices
.end ());
278 auto from
= std::unique (cu_indices
.begin (), cu_indices
.end ());
279 cu_indices
.erase (from
, cu_indices
.end ());
284 /* A form of 'const char *' suitable for container keys. Only the
285 pointer is stored. The strings themselves are compared, not the
290 c_str_view (const char *cstr
)
294 bool operator== (const c_str_view
&other
) const
296 return strcmp (m_cstr
, other
.m_cstr
) == 0;
299 /* Return the underlying C string. Note, the returned string is
300 only a reference with lifetime of this object. */
301 const char *c_str () const
307 friend class c_str_view_hasher
;
308 const char *const m_cstr
;
311 /* A std::unordered_map::hasher for c_str_view that uses the right
312 hash function for strings in a mapped index. */
313 class c_str_view_hasher
316 size_t operator () (const c_str_view
&x
) const
318 return mapped_index_string_hash (INT_MAX
, x
.m_cstr
);
322 /* A std::unordered_map::hasher for std::vector<>. */
327 size_t operator () (const std::vector
<T
> &key
) const
329 return iterative_hash (key
.data (),
330 sizeof (key
.front ()) * key
.size (), 0);
334 /* Write the mapped hash table SYMTAB to the data buffer OUTPUT, with
335 constant pool entries going into the data buffer CPOOL. */
338 write_hash_table (mapped_symtab
*symtab
, data_buf
&output
, data_buf
&cpool
)
341 /* Elements are sorted vectors of the indices of all the CUs that
342 hold an object of this name. */
343 std::unordered_map
<std::vector
<offset_type
>, offset_type
,
344 vector_hasher
<offset_type
>>
347 /* We add all the index vectors to the constant pool first, to
348 ensure alignment is ok. */
349 for (symtab_index_entry
&entry
: symtab
->data
)
351 if (entry
.name
== NULL
)
353 gdb_assert (entry
.index_offset
== 0);
355 /* Finding before inserting is faster than always trying to
356 insert, because inserting always allocates a node, does the
357 lookup, and then destroys the new node if another node
358 already had the same key. C++17 try_emplace will avoid
361 = symbol_hash_table
.find (entry
.cu_indices
);
362 if (found
!= symbol_hash_table
.end ())
364 entry
.index_offset
= found
->second
;
368 symbol_hash_table
.emplace (entry
.cu_indices
, cpool
.size ());
369 entry
.index_offset
= cpool
.size ();
370 cpool
.append_data (MAYBE_SWAP (entry
.cu_indices
.size ()));
371 for (const auto index
: entry
.cu_indices
)
372 cpool
.append_data (MAYBE_SWAP (index
));
376 /* Now write out the hash table. */
377 std::unordered_map
<c_str_view
, offset_type
, c_str_view_hasher
> str_table
;
378 for (const auto &entry
: symtab
->data
)
380 offset_type str_off
, vec_off
;
382 if (entry
.name
!= NULL
)
384 const auto insertpair
= str_table
.emplace (entry
.name
, cpool
.size ());
385 if (insertpair
.second
)
386 cpool
.append_cstr0 (entry
.name
);
387 str_off
= insertpair
.first
->second
;
388 vec_off
= entry
.index_offset
;
392 /* While 0 is a valid constant pool index, it is not valid
393 to have 0 for both offsets. */
398 output
.append_data (MAYBE_SWAP (str_off
));
399 output
.append_data (MAYBE_SWAP (vec_off
));
403 typedef std::unordered_map
<partial_symtab
*, unsigned int> psym_index_map
;
405 /* Helper struct for building the address table. */
406 struct addrmap_index_data
408 addrmap_index_data (data_buf
&addr_vec_
, psym_index_map
&cu_index_htab_
)
409 : addr_vec (addr_vec_
), cu_index_htab (cu_index_htab_
)
412 struct objfile
*objfile
;
414 psym_index_map
&cu_index_htab
;
416 /* Non-zero if the previous_* fields are valid.
417 We can't write an entry until we see the next entry (since it is only then
418 that we know the end of the entry). */
420 /* Index of the CU in the table of all CUs in the index file. */
421 unsigned int previous_cu_index
;
422 /* Start address of the CU. */
423 CORE_ADDR previous_cu_start
;
426 /* Write an address entry to ADDR_VEC. */
429 add_address_entry (struct objfile
*objfile
, data_buf
&addr_vec
,
430 CORE_ADDR start
, CORE_ADDR end
, unsigned int cu_index
)
432 addr_vec
.append_uint (8, BFD_ENDIAN_LITTLE
, start
);
433 addr_vec
.append_uint (8, BFD_ENDIAN_LITTLE
, end
);
434 addr_vec
.append_data (MAYBE_SWAP (cu_index
));
437 /* Worker function for traversing an addrmap to build the address table. */
440 add_address_entry_worker (void *datap
, CORE_ADDR start_addr
, void *obj
)
442 struct addrmap_index_data
*data
= (struct addrmap_index_data
*) datap
;
443 partial_symtab
*pst
= (partial_symtab
*) obj
;
445 if (data
->previous_valid
)
446 add_address_entry (data
->objfile
, data
->addr_vec
,
447 data
->previous_cu_start
, start_addr
,
448 data
->previous_cu_index
);
450 data
->previous_cu_start
= start_addr
;
453 const auto it
= data
->cu_index_htab
.find (pst
);
454 gdb_assert (it
!= data
->cu_index_htab
.cend ());
455 data
->previous_cu_index
= it
->second
;
456 data
->previous_valid
= 1;
459 data
->previous_valid
= 0;
464 /* Write OBJFILE's address map to ADDR_VEC.
465 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
466 in the index file. */
469 write_address_map (struct objfile
*objfile
, data_buf
&addr_vec
,
470 psym_index_map
&cu_index_htab
)
472 struct addrmap_index_data
addrmap_index_data (addr_vec
, cu_index_htab
);
474 /* When writing the address table, we have to cope with the fact that
475 the addrmap iterator only provides the start of a region; we have to
476 wait until the next invocation to get the start of the next region. */
478 addrmap_index_data
.objfile
= objfile
;
479 addrmap_index_data
.previous_valid
= 0;
481 addrmap_foreach (objfile
->partial_symtabs
->psymtabs_addrmap
,
482 add_address_entry_worker
, &addrmap_index_data
);
484 /* It's highly unlikely the last entry (end address = 0xff...ff)
485 is valid, but we should still handle it.
486 The end address is recorded as the start of the next region, but that
487 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
489 if (addrmap_index_data
.previous_valid
)
490 add_address_entry (objfile
, addr_vec
,
491 addrmap_index_data
.previous_cu_start
, (CORE_ADDR
) -1,
492 addrmap_index_data
.previous_cu_index
);
495 /* Return the symbol kind of PSYM. */
497 static gdb_index_symbol_kind
498 symbol_kind (struct partial_symbol
*psym
)
500 domain_enum domain
= psym
->domain
;
501 enum address_class aclass
= psym
->aclass
;
509 return GDB_INDEX_SYMBOL_KIND_FUNCTION
;
511 return GDB_INDEX_SYMBOL_KIND_TYPE
;
513 case LOC_CONST_BYTES
:
514 case LOC_OPTIMIZED_OUT
:
516 return GDB_INDEX_SYMBOL_KIND_VARIABLE
;
518 /* Note: It's currently impossible to recognize psyms as enum values
519 short of reading the type info. For now punt. */
520 return GDB_INDEX_SYMBOL_KIND_VARIABLE
;
522 /* There are other LOC_FOO values that one might want to classify
523 as variables, but dwarf2read.c doesn't currently use them. */
524 return GDB_INDEX_SYMBOL_KIND_OTHER
;
527 return GDB_INDEX_SYMBOL_KIND_TYPE
;
529 return GDB_INDEX_SYMBOL_KIND_OTHER
;
533 /* Add a list of partial symbols to SYMTAB. */
536 write_psymbols (struct mapped_symtab
*symtab
,
537 std::unordered_set
<partial_symbol
*> &psyms_seen
,
538 struct partial_symbol
**psymp
,
540 offset_type cu_index
,
543 for (; count
-- > 0; ++psymp
)
545 struct partial_symbol
*psym
= *psymp
;
547 if (psym
->ginfo
.language () == language_ada
)
548 error (_("Ada is not currently supported by the index; "
549 "use the DWARF 5 index instead"));
551 /* Only add a given psymbol once. */
552 if (psyms_seen
.insert (psym
).second
)
554 gdb_index_symbol_kind kind
= symbol_kind (psym
);
556 add_index_entry (symtab
, psym
->ginfo
.search_name (),
557 is_static
, kind
, cu_index
);
562 /* A helper struct used when iterating over debug_types. */
563 struct signatured_type_index_data
565 signatured_type_index_data (data_buf
&types_list_
,
566 std::unordered_set
<partial_symbol
*> &psyms_seen_
)
567 : types_list (types_list_
), psyms_seen (psyms_seen_
)
570 struct objfile
*objfile
;
571 struct mapped_symtab
*symtab
;
572 data_buf
&types_list
;
573 std::unordered_set
<partial_symbol
*> &psyms_seen
;
577 /* A helper function that writes a single signatured_type to an
581 write_one_signatured_type (void **slot
, void *d
)
583 struct signatured_type_index_data
*info
584 = (struct signatured_type_index_data
*) d
;
585 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
586 partial_symtab
*psymtab
= entry
->per_cu
.v
.psymtab
;
588 write_psymbols (info
->symtab
,
590 (info
->objfile
->partial_symtabs
->global_psymbols
.data ()
591 + psymtab
->globals_offset
),
592 psymtab
->n_global_syms
, info
->cu_index
,
594 write_psymbols (info
->symtab
,
596 (info
->objfile
->partial_symtabs
->static_psymbols
.data ()
597 + psymtab
->statics_offset
),
598 psymtab
->n_static_syms
, info
->cu_index
,
601 info
->types_list
.append_uint (8, BFD_ENDIAN_LITTLE
,
602 to_underlying (entry
->per_cu
.sect_off
));
603 info
->types_list
.append_uint (8, BFD_ENDIAN_LITTLE
,
604 to_underlying (entry
->type_offset_in_tu
));
605 info
->types_list
.append_uint (8, BFD_ENDIAN_LITTLE
, entry
->signature
);
612 /* Recurse into all "included" dependencies and count their symbols as
613 if they appeared in this psymtab. */
616 recursively_count_psymbols (partial_symtab
*psymtab
,
619 for (int i
= 0; i
< psymtab
->number_of_dependencies
; ++i
)
620 if (psymtab
->dependencies
[i
]->user
!= NULL
)
621 recursively_count_psymbols (psymtab
->dependencies
[i
],
624 psyms_seen
+= psymtab
->n_global_syms
;
625 psyms_seen
+= psymtab
->n_static_syms
;
628 /* Recurse into all "included" dependencies and write their symbols as
629 if they appeared in this psymtab. */
632 recursively_write_psymbols (struct objfile
*objfile
,
633 partial_symtab
*psymtab
,
634 struct mapped_symtab
*symtab
,
635 std::unordered_set
<partial_symbol
*> &psyms_seen
,
636 offset_type cu_index
)
640 for (i
= 0; i
< psymtab
->number_of_dependencies
; ++i
)
641 if (psymtab
->dependencies
[i
]->user
!= NULL
)
642 recursively_write_psymbols (objfile
,
643 psymtab
->dependencies
[i
],
644 symtab
, psyms_seen
, cu_index
);
646 write_psymbols (symtab
,
648 (objfile
->partial_symtabs
->global_psymbols
.data ()
649 + psymtab
->globals_offset
),
650 psymtab
->n_global_syms
, cu_index
,
652 write_psymbols (symtab
,
654 (objfile
->partial_symtabs
->static_psymbols
.data ()
655 + psymtab
->statics_offset
),
656 psymtab
->n_static_syms
, cu_index
,
660 /* DWARF-5 .debug_names builder. */
664 debug_names (struct dwarf2_per_objfile
*dwarf2_per_objfile
, bool is_dwarf64
,
665 bfd_endian dwarf5_byte_order
)
666 : m_dwarf5_byte_order (dwarf5_byte_order
),
667 m_dwarf32 (dwarf5_byte_order
),
668 m_dwarf64 (dwarf5_byte_order
),
670 ? static_cast<dwarf
&> (m_dwarf64
)
671 : static_cast<dwarf
&> (m_dwarf32
)),
672 m_name_table_string_offs (m_dwarf
.name_table_string_offs
),
673 m_name_table_entry_offs (m_dwarf
.name_table_entry_offs
),
674 m_debugstrlookup (dwarf2_per_objfile
)
677 int dwarf5_offset_size () const
679 const bool dwarf5_is_dwarf64
= &m_dwarf
== &m_dwarf64
;
680 return dwarf5_is_dwarf64
? 8 : 4;
683 /* Is this symbol from DW_TAG_compile_unit or DW_TAG_type_unit? */
684 enum class unit_kind
{ cu
, tu
};
686 /* Insert one symbol. */
687 void insert (const partial_symbol
*psym
, int cu_index
, bool is_static
,
690 const int dwarf_tag
= psymbol_tag (psym
);
693 const char *name
= psym
->ginfo
.search_name ();
695 if (psym
->ginfo
.language () == language_ada
)
697 /* We want to ensure that the Ada main function's name appears
698 verbatim in the index. However, this name will be of the
699 form "_ada_mumble", and will be rewritten by ada_decode.
700 So, recognize it specially here and add it to the index by
702 if (strcmp (main_name (), name
) == 0)
704 const auto insertpair
705 = m_name_to_value_set
.emplace (c_str_view (name
),
706 std::set
<symbol_value
> ());
707 std::set
<symbol_value
> &value_set
= insertpair
.first
->second
;
708 value_set
.emplace (symbol_value (dwarf_tag
, cu_index
, is_static
,
712 /* In order for the index to work when read back into gdb, it
713 has to supply a funny form of the name: it should be the
714 encoded name, with any suffixes stripped. Using the
715 ordinary encoded name will not work properly with the
716 searching logic in find_name_components_bounds; nor will
717 using the decoded name. Furthermore, an Ada "verbatim"
718 name (of the form "<MumBle>") must be entered without the
719 angle brackets. Note that the current index is unusual,
720 see PR symtab/24820 for details. */
721 std::string decoded
= ada_decode (name
);
722 if (decoded
[0] == '<')
723 name
= (char *) obstack_copy0 (&m_string_obstack
,
724 decoded
.c_str () + 1,
725 decoded
.length () - 2);
727 name
= obstack_strdup (&m_string_obstack
,
728 ada_encode (decoded
.c_str ()));
731 const auto insertpair
732 = m_name_to_value_set
.emplace (c_str_view (name
),
733 std::set
<symbol_value
> ());
734 std::set
<symbol_value
> &value_set
= insertpair
.first
->second
;
735 value_set
.emplace (symbol_value (dwarf_tag
, cu_index
, is_static
, kind
));
738 /* Build all the tables. All symbols must be already inserted.
739 This function does not call file_write, caller has to do it
743 /* Verify the build method has not be called twice. */
744 gdb_assert (m_abbrev_table
.empty ());
745 const size_t name_count
= m_name_to_value_set
.size ();
746 m_bucket_table
.resize
747 (std::pow (2, std::ceil (std::log2 (name_count
* 4 / 3))));
748 m_hash_table
.reserve (name_count
);
749 m_name_table_string_offs
.reserve (name_count
);
750 m_name_table_entry_offs
.reserve (name_count
);
752 /* Map each hash of symbol to its name and value. */
756 decltype (m_name_to_value_set
)::const_iterator it
;
758 std::vector
<std::forward_list
<hash_it_pair
>> bucket_hash
;
759 bucket_hash
.resize (m_bucket_table
.size ());
760 for (decltype (m_name_to_value_set
)::const_iterator it
761 = m_name_to_value_set
.cbegin ();
762 it
!= m_name_to_value_set
.cend ();
765 const char *const name
= it
->first
.c_str ();
766 const uint32_t hash
= dwarf5_djb_hash (name
);
767 hash_it_pair hashitpair
;
768 hashitpair
.hash
= hash
;
770 auto &slot
= bucket_hash
[hash
% bucket_hash
.size()];
771 slot
.push_front (std::move (hashitpair
));
773 for (size_t bucket_ix
= 0; bucket_ix
< bucket_hash
.size (); ++bucket_ix
)
775 const std::forward_list
<hash_it_pair
> &hashitlist
776 = bucket_hash
[bucket_ix
];
777 if (hashitlist
.empty ())
779 uint32_t &bucket_slot
= m_bucket_table
[bucket_ix
];
780 /* The hashes array is indexed starting at 1. */
781 store_unsigned_integer (reinterpret_cast<gdb_byte
*> (&bucket_slot
),
782 sizeof (bucket_slot
), m_dwarf5_byte_order
,
783 m_hash_table
.size () + 1);
784 for (const hash_it_pair
&hashitpair
: hashitlist
)
786 m_hash_table
.push_back (0);
787 store_unsigned_integer (reinterpret_cast<gdb_byte
*>
788 (&m_hash_table
.back ()),
789 sizeof (m_hash_table
.back ()),
790 m_dwarf5_byte_order
, hashitpair
.hash
);
791 const c_str_view
&name
= hashitpair
.it
->first
;
792 const std::set
<symbol_value
> &value_set
= hashitpair
.it
->second
;
793 m_name_table_string_offs
.push_back_reorder
794 (m_debugstrlookup
.lookup (name
.c_str ()));
795 m_name_table_entry_offs
.push_back_reorder (m_entry_pool
.size ());
796 gdb_assert (!value_set
.empty ());
797 for (const symbol_value
&value
: value_set
)
799 int &idx
= m_indexkey_to_idx
[index_key (value
.dwarf_tag
,
805 m_abbrev_table
.append_unsigned_leb128 (idx
);
806 m_abbrev_table
.append_unsigned_leb128 (value
.dwarf_tag
);
807 m_abbrev_table
.append_unsigned_leb128
808 (value
.kind
== unit_kind::cu
? DW_IDX_compile_unit
810 m_abbrev_table
.append_unsigned_leb128 (DW_FORM_udata
);
811 m_abbrev_table
.append_unsigned_leb128 (value
.is_static
812 ? DW_IDX_GNU_internal
813 : DW_IDX_GNU_external
);
814 m_abbrev_table
.append_unsigned_leb128 (DW_FORM_flag_present
);
816 /* Terminate attributes list. */
817 m_abbrev_table
.append_unsigned_leb128 (0);
818 m_abbrev_table
.append_unsigned_leb128 (0);
821 m_entry_pool
.append_unsigned_leb128 (idx
);
822 m_entry_pool
.append_unsigned_leb128 (value
.cu_index
);
825 /* Terminate the list of CUs. */
826 m_entry_pool
.append_unsigned_leb128 (0);
829 gdb_assert (m_hash_table
.size () == name_count
);
831 /* Terminate tags list. */
832 m_abbrev_table
.append_unsigned_leb128 (0);
835 /* Return .debug_names bucket count. This must be called only after
836 calling the build method. */
837 uint32_t bucket_count () const
839 /* Verify the build method has been already called. */
840 gdb_assert (!m_abbrev_table
.empty ());
841 const uint32_t retval
= m_bucket_table
.size ();
843 /* Check for overflow. */
844 gdb_assert (retval
== m_bucket_table
.size ());
848 /* Return .debug_names names count. This must be called only after
849 calling the build method. */
850 uint32_t name_count () const
852 /* Verify the build method has been already called. */
853 gdb_assert (!m_abbrev_table
.empty ());
854 const uint32_t retval
= m_hash_table
.size ();
856 /* Check for overflow. */
857 gdb_assert (retval
== m_hash_table
.size ());
861 /* Return number of bytes of .debug_names abbreviation table. This
862 must be called only after calling the build method. */
863 uint32_t abbrev_table_bytes () const
865 gdb_assert (!m_abbrev_table
.empty ());
866 return m_abbrev_table
.size ();
869 /* Recurse into all "included" dependencies and store their symbols
870 as if they appeared in this psymtab. */
871 void recursively_write_psymbols
872 (struct objfile
*objfile
,
873 partial_symtab
*psymtab
,
874 std::unordered_set
<partial_symbol
*> &psyms_seen
,
877 for (int i
= 0; i
< psymtab
->number_of_dependencies
; ++i
)
878 if (psymtab
->dependencies
[i
]->user
!= NULL
)
879 recursively_write_psymbols
880 (objfile
, psymtab
->dependencies
[i
], psyms_seen
, cu_index
);
882 write_psymbols (psyms_seen
,
883 (objfile
->partial_symtabs
->global_psymbols
.data ()
884 + psymtab
->globals_offset
),
885 psymtab
->n_global_syms
, cu_index
, false, unit_kind::cu
);
886 write_psymbols (psyms_seen
,
887 (objfile
->partial_symtabs
->static_psymbols
.data ()
888 + psymtab
->statics_offset
),
889 psymtab
->n_static_syms
, cu_index
, true, unit_kind::cu
);
892 /* Return number of bytes the .debug_names section will have. This
893 must be called only after calling the build method. */
894 size_t bytes () const
896 /* Verify the build method has been already called. */
897 gdb_assert (!m_abbrev_table
.empty ());
898 size_t expected_bytes
= 0;
899 expected_bytes
+= m_bucket_table
.size () * sizeof (m_bucket_table
[0]);
900 expected_bytes
+= m_hash_table
.size () * sizeof (m_hash_table
[0]);
901 expected_bytes
+= m_name_table_string_offs
.bytes ();
902 expected_bytes
+= m_name_table_entry_offs
.bytes ();
903 expected_bytes
+= m_abbrev_table
.size ();
904 expected_bytes
+= m_entry_pool
.size ();
905 return expected_bytes
;
908 /* Write .debug_names to FILE_NAMES and .debug_str addition to
909 FILE_STR. This must be called only after calling the build
911 void file_write (FILE *file_names
, FILE *file_str
) const
913 /* Verify the build method has been already called. */
914 gdb_assert (!m_abbrev_table
.empty ());
915 ::file_write (file_names
, m_bucket_table
);
916 ::file_write (file_names
, m_hash_table
);
917 m_name_table_string_offs
.file_write (file_names
);
918 m_name_table_entry_offs
.file_write (file_names
);
919 m_abbrev_table
.file_write (file_names
);
920 m_entry_pool
.file_write (file_names
);
921 m_debugstrlookup
.file_write (file_str
);
924 /* A helper user data for write_one_signatured_type. */
925 class write_one_signatured_type_data
928 write_one_signatured_type_data (debug_names
&nametable_
,
929 signatured_type_index_data
&&info_
)
930 : nametable (nametable_
), info (std::move (info_
))
932 debug_names
&nametable
;
933 struct signatured_type_index_data info
;
936 /* A helper function to pass write_one_signatured_type to
937 htab_traverse_noresize. */
939 write_one_signatured_type (void **slot
, void *d
)
941 write_one_signatured_type_data
*data
= (write_one_signatured_type_data
*) d
;
942 struct signatured_type_index_data
*info
= &data
->info
;
943 struct signatured_type
*entry
= (struct signatured_type
*) *slot
;
945 data
->nametable
.write_one_signatured_type (entry
, info
);
952 /* Storage for symbol names mapping them to their .debug_str section
954 class debug_str_lookup
958 /* Object constructor to be called for current DWARF2_PER_OBJFILE.
959 All .debug_str section strings are automatically stored. */
960 debug_str_lookup (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
961 : m_abfd (dwarf2_per_objfile
->objfile
->obfd
),
962 m_dwarf2_per_objfile (dwarf2_per_objfile
)
964 dwarf2_per_objfile
->per_bfd
->str
.read (dwarf2_per_objfile
->objfile
);
965 if (dwarf2_per_objfile
->per_bfd
->str
.buffer
== NULL
)
967 for (const gdb_byte
*data
= dwarf2_per_objfile
->per_bfd
->str
.buffer
;
968 data
< (dwarf2_per_objfile
->per_bfd
->str
.buffer
969 + dwarf2_per_objfile
->per_bfd
->str
.size
);)
971 const char *const s
= reinterpret_cast<const char *> (data
);
972 const auto insertpair
973 = m_str_table
.emplace (c_str_view (s
),
974 data
- dwarf2_per_objfile
->per_bfd
->str
.buffer
);
975 if (!insertpair
.second
)
976 complaint (_("Duplicate string \"%s\" in "
977 ".debug_str section [in module %s]"),
978 s
, bfd_get_filename (m_abfd
));
979 data
+= strlen (s
) + 1;
983 /* Return offset of symbol name S in the .debug_str section. Add
984 such symbol to the section's end if it does not exist there
986 size_t lookup (const char *s
)
988 const auto it
= m_str_table
.find (c_str_view (s
));
989 if (it
!= m_str_table
.end ())
991 const size_t offset
= (m_dwarf2_per_objfile
->per_bfd
->str
.size
992 + m_str_add_buf
.size ());
993 m_str_table
.emplace (c_str_view (s
), offset
);
994 m_str_add_buf
.append_cstr0 (s
);
998 /* Append the end of the .debug_str section to FILE. */
999 void file_write (FILE *file
) const
1001 m_str_add_buf
.file_write (file
);
1005 std::unordered_map
<c_str_view
, size_t, c_str_view_hasher
> m_str_table
;
1007 struct dwarf2_per_objfile
*m_dwarf2_per_objfile
;
1009 /* Data to add at the end of .debug_str for new needed symbol names. */
1010 data_buf m_str_add_buf
;
1013 /* Container to map used DWARF tags to their .debug_names abbreviation
1018 index_key (int dwarf_tag_
, bool is_static_
, unit_kind kind_
)
1019 : dwarf_tag (dwarf_tag_
), is_static (is_static_
), kind (kind_
)
1024 operator== (const index_key
&other
) const
1026 return (dwarf_tag
== other
.dwarf_tag
&& is_static
== other
.is_static
1027 && kind
== other
.kind
);
1030 const int dwarf_tag
;
1031 const bool is_static
;
1032 const unit_kind kind
;
1035 /* Provide std::unordered_map::hasher for index_key. */
1036 class index_key_hasher
1040 operator () (const index_key
&key
) const
1042 return (std::hash
<int>() (key
.dwarf_tag
) << 1) | key
.is_static
;
1046 /* Parameters of one symbol entry. */
1050 const int dwarf_tag
, cu_index
;
1051 const bool is_static
;
1052 const unit_kind kind
;
1054 symbol_value (int dwarf_tag_
, int cu_index_
, bool is_static_
,
1056 : dwarf_tag (dwarf_tag_
), cu_index (cu_index_
), is_static (is_static_
),
1061 operator< (const symbol_value
&other
) const
1081 /* Abstract base class to unify DWARF-32 and DWARF-64 name table
1086 const bfd_endian dwarf5_byte_order
;
1088 explicit offset_vec (bfd_endian dwarf5_byte_order_
)
1089 : dwarf5_byte_order (dwarf5_byte_order_
)
1092 /* Call std::vector::reserve for NELEM elements. */
1093 virtual void reserve (size_t nelem
) = 0;
1095 /* Call std::vector::push_back with store_unsigned_integer byte
1096 reordering for ELEM. */
1097 virtual void push_back_reorder (size_t elem
) = 0;
1099 /* Return expected output size in bytes. */
1100 virtual size_t bytes () const = 0;
1102 /* Write name table to FILE. */
1103 virtual void file_write (FILE *file
) const = 0;
1106 /* Template to unify DWARF-32 and DWARF-64 output. */
1107 template<typename OffsetSize
>
1108 class offset_vec_tmpl
: public offset_vec
1111 explicit offset_vec_tmpl (bfd_endian dwarf5_byte_order_
)
1112 : offset_vec (dwarf5_byte_order_
)
1115 /* Implement offset_vec::reserve. */
1116 void reserve (size_t nelem
) override
1118 m_vec
.reserve (nelem
);
1121 /* Implement offset_vec::push_back_reorder. */
1122 void push_back_reorder (size_t elem
) override
1124 m_vec
.push_back (elem
);
1125 /* Check for overflow. */
1126 gdb_assert (m_vec
.back () == elem
);
1127 store_unsigned_integer (reinterpret_cast<gdb_byte
*> (&m_vec
.back ()),
1128 sizeof (m_vec
.back ()), dwarf5_byte_order
, elem
);
1131 /* Implement offset_vec::bytes. */
1132 size_t bytes () const override
1134 return m_vec
.size () * sizeof (m_vec
[0]);
1137 /* Implement offset_vec::file_write. */
1138 void file_write (FILE *file
) const override
1140 ::file_write (file
, m_vec
);
1144 std::vector
<OffsetSize
> m_vec
;
1147 /* Base class to unify DWARF-32 and DWARF-64 .debug_names output
1148 respecting name table width. */
1152 offset_vec
&name_table_string_offs
, &name_table_entry_offs
;
1154 dwarf (offset_vec
&name_table_string_offs_
,
1155 offset_vec
&name_table_entry_offs_
)
1156 : name_table_string_offs (name_table_string_offs_
),
1157 name_table_entry_offs (name_table_entry_offs_
)
1162 /* Template to unify DWARF-32 and DWARF-64 .debug_names output
1163 respecting name table width. */
1164 template<typename OffsetSize
>
1165 class dwarf_tmpl
: public dwarf
1168 explicit dwarf_tmpl (bfd_endian dwarf5_byte_order_
)
1169 : dwarf (m_name_table_string_offs
, m_name_table_entry_offs
),
1170 m_name_table_string_offs (dwarf5_byte_order_
),
1171 m_name_table_entry_offs (dwarf5_byte_order_
)
1175 offset_vec_tmpl
<OffsetSize
> m_name_table_string_offs
;
1176 offset_vec_tmpl
<OffsetSize
> m_name_table_entry_offs
;
1179 /* Try to reconstruct original DWARF tag for given partial_symbol.
1180 This function is not DWARF-5 compliant but it is sufficient for
1181 GDB as a DWARF-5 index consumer. */
1182 static int psymbol_tag (const struct partial_symbol
*psym
)
1184 domain_enum domain
= psym
->domain
;
1185 enum address_class aclass
= psym
->aclass
;
1193 return DW_TAG_subprogram
;
1195 return DW_TAG_typedef
;
1197 case LOC_CONST_BYTES
:
1198 case LOC_OPTIMIZED_OUT
:
1200 return DW_TAG_variable
;
1202 /* Note: It's currently impossible to recognize psyms as enum values
1203 short of reading the type info. For now punt. */
1204 return DW_TAG_variable
;
1206 /* There are other LOC_FOO values that one might want to classify
1207 as variables, but dwarf2read.c doesn't currently use them. */
1208 return DW_TAG_variable
;
1211 return DW_TAG_structure_type
;
1213 return DW_TAG_module
;
1219 /* Call insert for all partial symbols and mark them in PSYMS_SEEN. */
1220 void write_psymbols (std::unordered_set
<partial_symbol
*> &psyms_seen
,
1221 struct partial_symbol
**psymp
, int count
, int cu_index
,
1222 bool is_static
, unit_kind kind
)
1224 for (; count
-- > 0; ++psymp
)
1226 struct partial_symbol
*psym
= *psymp
;
1228 /* Only add a given psymbol once. */
1229 if (psyms_seen
.insert (psym
).second
)
1230 insert (psym
, cu_index
, is_static
, kind
);
1234 /* A helper function that writes a single signatured_type
1235 to a debug_names. */
1237 write_one_signatured_type (struct signatured_type
*entry
,
1238 struct signatured_type_index_data
*info
)
1240 partial_symtab
*psymtab
= entry
->per_cu
.v
.psymtab
;
1242 write_psymbols (info
->psyms_seen
,
1243 (info
->objfile
->partial_symtabs
->global_psymbols
.data ()
1244 + psymtab
->globals_offset
),
1245 psymtab
->n_global_syms
, info
->cu_index
, false,
1247 write_psymbols (info
->psyms_seen
,
1248 (info
->objfile
->partial_symtabs
->static_psymbols
.data ()
1249 + psymtab
->statics_offset
),
1250 psymtab
->n_static_syms
, info
->cu_index
, true,
1253 info
->types_list
.append_uint (dwarf5_offset_size (), m_dwarf5_byte_order
,
1254 to_underlying (entry
->per_cu
.sect_off
));
1259 /* Store value of each symbol. */
1260 std::unordered_map
<c_str_view
, std::set
<symbol_value
>, c_str_view_hasher
>
1261 m_name_to_value_set
;
1263 /* Tables of DWARF-5 .debug_names. They are in object file byte
1265 std::vector
<uint32_t> m_bucket_table
;
1266 std::vector
<uint32_t> m_hash_table
;
1268 const bfd_endian m_dwarf5_byte_order
;
1269 dwarf_tmpl
<uint32_t> m_dwarf32
;
1270 dwarf_tmpl
<uint64_t> m_dwarf64
;
1272 offset_vec
&m_name_table_string_offs
, &m_name_table_entry_offs
;
1273 debug_str_lookup m_debugstrlookup
;
1275 /* Map each used .debug_names abbreviation tag parameter to its
1277 std::unordered_map
<index_key
, int, index_key_hasher
> m_indexkey_to_idx
;
1279 /* Next unused .debug_names abbreviation tag for
1280 m_indexkey_to_idx. */
1283 /* .debug_names abbreviation table. */
1284 data_buf m_abbrev_table
;
1286 /* .debug_names entry pool. */
1287 data_buf m_entry_pool
;
1289 /* Temporary storage for Ada names. */
1290 auto_obstack m_string_obstack
;
1293 /* Return iff any of the needed offsets does not fit into 32-bit
1294 .debug_names section. */
1297 check_dwarf64_offsets (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
1299 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->per_bfd
->all_comp_units
)
1301 if (to_underlying (per_cu
->sect_off
) >= (static_cast<uint64_t> (1) << 32))
1304 for (const signatured_type
*sigtype
: dwarf2_per_objfile
->per_bfd
->all_type_units
)
1306 const dwarf2_per_cu_data
&per_cu
= sigtype
->per_cu
;
1308 if (to_underlying (per_cu
.sect_off
) >= (static_cast<uint64_t> (1) << 32))
1314 /* The psyms_seen set is potentially going to be largish (~40k
1315 elements when indexing a -g3 build of GDB itself). Estimate the
1316 number of elements in order to avoid too many rehashes, which
1317 require rebuilding buckets and thus many trips to
1321 psyms_seen_size (struct dwarf2_per_objfile
*dwarf2_per_objfile
)
1323 size_t psyms_count
= 0;
1324 for (dwarf2_per_cu_data
*per_cu
: dwarf2_per_objfile
->per_bfd
->all_comp_units
)
1326 partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
1328 if (psymtab
!= NULL
&& psymtab
->user
== NULL
)
1329 recursively_count_psymbols (psymtab
, psyms_count
);
1331 /* Generating an index for gdb itself shows a ratio of
1332 TOTAL_SEEN_SYMS/UNIQUE_SYMS or ~5. 4 seems like a good bet. */
1333 return psyms_count
/ 4;
1336 /* Assert that FILE's size is EXPECTED_SIZE. Assumes file's seek
1337 position is at the end of the file. */
1340 assert_file_size (FILE *file
, size_t expected_size
)
1342 const auto file_size
= ftell (file
);
1343 if (file_size
== -1)
1344 perror_with_name (("ftell"));
1345 gdb_assert (file_size
== expected_size
);
1348 /* Write a gdb index file to OUT_FILE from all the sections passed as
1352 write_gdbindex_1 (FILE *out_file
,
1353 const data_buf
&cu_list
,
1354 const data_buf
&types_cu_list
,
1355 const data_buf
&addr_vec
,
1356 const data_buf
&symtab_vec
,
1357 const data_buf
&constant_pool
)
1360 const offset_type size_of_header
= 6 * sizeof (offset_type
);
1361 offset_type total_len
= size_of_header
;
1363 /* The version number. */
1364 contents
.append_data (MAYBE_SWAP (8));
1366 /* The offset of the CU list from the start of the file. */
1367 contents
.append_data (MAYBE_SWAP (total_len
));
1368 total_len
+= cu_list
.size ();
1370 /* The offset of the types CU list from the start of the file. */
1371 contents
.append_data (MAYBE_SWAP (total_len
));
1372 total_len
+= types_cu_list
.size ();
1374 /* The offset of the address table from the start of the file. */
1375 contents
.append_data (MAYBE_SWAP (total_len
));
1376 total_len
+= addr_vec
.size ();
1378 /* The offset of the symbol table from the start of the file. */
1379 contents
.append_data (MAYBE_SWAP (total_len
));
1380 total_len
+= symtab_vec
.size ();
1382 /* The offset of the constant pool from the start of the file. */
1383 contents
.append_data (MAYBE_SWAP (total_len
));
1384 total_len
+= constant_pool
.size ();
1386 gdb_assert (contents
.size () == size_of_header
);
1388 contents
.file_write (out_file
);
1389 cu_list
.file_write (out_file
);
1390 types_cu_list
.file_write (out_file
);
1391 addr_vec
.file_write (out_file
);
1392 symtab_vec
.file_write (out_file
);
1393 constant_pool
.file_write (out_file
);
1395 assert_file_size (out_file
, total_len
);
1398 /* Write contents of a .gdb_index section for OBJFILE into OUT_FILE.
1399 If OBJFILE has an associated dwz file, write contents of a .gdb_index
1400 section for that dwz file into DWZ_OUT_FILE. If OBJFILE does not have an
1401 associated dwz file, DWZ_OUT_FILE must be NULL. */
1404 write_gdbindex (struct dwarf2_per_objfile
*dwarf2_per_objfile
, FILE *out_file
,
1407 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
1408 mapped_symtab symtab
;
1409 data_buf objfile_cu_list
;
1410 data_buf dwz_cu_list
;
1412 /* While we're scanning CU's create a table that maps a psymtab pointer
1413 (which is what addrmap records) to its index (which is what is recorded
1414 in the index file). This will later be needed to write the address
1416 psym_index_map cu_index_htab
;
1417 cu_index_htab
.reserve (dwarf2_per_objfile
->per_bfd
->all_comp_units
.size ());
1419 /* The CU list is already sorted, so we don't need to do additional
1420 work here. Also, the debug_types entries do not appear in
1421 all_comp_units, but only in their own hash table. */
1423 std::unordered_set
<partial_symbol
*> psyms_seen
1424 (psyms_seen_size (dwarf2_per_objfile
));
1425 for (int i
= 0; i
< dwarf2_per_objfile
->per_bfd
->all_comp_units
.size (); ++i
)
1427 struct dwarf2_per_cu_data
*per_cu
1428 = dwarf2_per_objfile
->per_bfd
->all_comp_units
[i
];
1429 partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
1431 if (psymtab
!= NULL
)
1433 if (psymtab
->user
== NULL
)
1434 recursively_write_psymbols (objfile
, psymtab
, &symtab
,
1437 const auto insertpair
= cu_index_htab
.emplace (psymtab
, i
);
1438 gdb_assert (insertpair
.second
);
1441 /* The all_comp_units list contains CUs read from the objfile as well as
1442 from the eventual dwz file. We need to place the entry in the
1443 corresponding index. */
1444 data_buf
&cu_list
= per_cu
->is_dwz
? dwz_cu_list
: objfile_cu_list
;
1445 cu_list
.append_uint (8, BFD_ENDIAN_LITTLE
,
1446 to_underlying (per_cu
->sect_off
));
1447 cu_list
.append_uint (8, BFD_ENDIAN_LITTLE
, per_cu
->length
);
1450 /* Dump the address map. */
1452 write_address_map (objfile
, addr_vec
, cu_index_htab
);
1454 /* Write out the .debug_type entries, if any. */
1455 data_buf types_cu_list
;
1456 if (dwarf2_per_objfile
->per_bfd
->signatured_types
)
1458 signatured_type_index_data
sig_data (types_cu_list
,
1461 sig_data
.objfile
= objfile
;
1462 sig_data
.symtab
= &symtab
;
1463 sig_data
.cu_index
= dwarf2_per_objfile
->per_bfd
->all_comp_units
.size ();
1464 htab_traverse_noresize (dwarf2_per_objfile
->per_bfd
->signatured_types
.get (),
1465 write_one_signatured_type
, &sig_data
);
1468 /* Now that we've processed all symbols we can shrink their cu_indices
1470 uniquify_cu_indices (&symtab
);
1472 data_buf symtab_vec
, constant_pool
;
1473 write_hash_table (&symtab
, symtab_vec
, constant_pool
);
1475 write_gdbindex_1(out_file
, objfile_cu_list
, types_cu_list
, addr_vec
,
1476 symtab_vec
, constant_pool
);
1478 if (dwz_out_file
!= NULL
)
1479 write_gdbindex_1 (dwz_out_file
, dwz_cu_list
, {}, {}, {}, {});
1481 gdb_assert (dwz_cu_list
.empty ());
1484 /* DWARF-5 augmentation string for GDB's DW_IDX_GNU_* extension. */
1485 static const gdb_byte dwarf5_gdb_augmentation
[] = { 'G', 'D', 'B', 0 };
1487 /* Write a new .debug_names section for OBJFILE into OUT_FILE, write
1488 needed addition to .debug_str section to OUT_FILE_STR. Return how
1489 many bytes were expected to be written into OUT_FILE. */
1492 write_debug_names (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
1493 FILE *out_file
, FILE *out_file_str
)
1495 const bool dwarf5_is_dwarf64
= check_dwarf64_offsets (dwarf2_per_objfile
);
1496 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
1497 const enum bfd_endian dwarf5_byte_order
1498 = gdbarch_byte_order (objfile
->arch ());
1500 /* The CU list is already sorted, so we don't need to do additional
1501 work here. Also, the debug_types entries do not appear in
1502 all_comp_units, but only in their own hash table. */
1504 debug_names
nametable (dwarf2_per_objfile
, dwarf5_is_dwarf64
,
1506 std::unordered_set
<partial_symbol
*>
1507 psyms_seen (psyms_seen_size (dwarf2_per_objfile
));
1508 for (int i
= 0; i
< dwarf2_per_objfile
->per_bfd
->all_comp_units
.size (); ++i
)
1510 const dwarf2_per_cu_data
*per_cu
= dwarf2_per_objfile
->per_bfd
->all_comp_units
[i
];
1511 partial_symtab
*psymtab
= per_cu
->v
.psymtab
;
1513 /* CU of a shared file from 'dwz -m' may be unused by this main
1514 file. It may be referenced from a local scope but in such
1515 case it does not need to be present in .debug_names. */
1516 if (psymtab
== NULL
)
1519 if (psymtab
->user
== NULL
)
1520 nametable
.recursively_write_psymbols (objfile
, psymtab
, psyms_seen
, i
);
1522 cu_list
.append_uint (nametable
.dwarf5_offset_size (), dwarf5_byte_order
,
1523 to_underlying (per_cu
->sect_off
));
1526 /* Write out the .debug_type entries, if any. */
1527 data_buf types_cu_list
;
1528 if (dwarf2_per_objfile
->per_bfd
->signatured_types
)
1530 debug_names::write_one_signatured_type_data
sig_data (nametable
,
1531 signatured_type_index_data (types_cu_list
, psyms_seen
));
1533 sig_data
.info
.objfile
= objfile
;
1534 /* It is used only for gdb_index. */
1535 sig_data
.info
.symtab
= nullptr;
1536 sig_data
.info
.cu_index
= 0;
1537 htab_traverse_noresize (dwarf2_per_objfile
->per_bfd
->signatured_types
.get (),
1538 debug_names::write_one_signatured_type
,
1544 /* No addr_vec - DWARF-5 uses .debug_aranges generated by GCC. */
1546 const offset_type bytes_of_header
1547 = ((dwarf5_is_dwarf64
? 12 : 4)
1549 + sizeof (dwarf5_gdb_augmentation
));
1550 size_t expected_bytes
= 0;
1551 expected_bytes
+= bytes_of_header
;
1552 expected_bytes
+= cu_list
.size ();
1553 expected_bytes
+= types_cu_list
.size ();
1554 expected_bytes
+= nametable
.bytes ();
1557 if (!dwarf5_is_dwarf64
)
1559 const uint64_t size64
= expected_bytes
- 4;
1560 gdb_assert (size64
< 0xfffffff0);
1561 header
.append_uint (4, dwarf5_byte_order
, size64
);
1565 header
.append_uint (4, dwarf5_byte_order
, 0xffffffff);
1566 header
.append_uint (8, dwarf5_byte_order
, expected_bytes
- 12);
1569 /* The version number. */
1570 header
.append_uint (2, dwarf5_byte_order
, 5);
1573 header
.append_uint (2, dwarf5_byte_order
, 0);
1575 /* comp_unit_count - The number of CUs in the CU list. */
1576 header
.append_uint (4, dwarf5_byte_order
,
1577 dwarf2_per_objfile
->per_bfd
->all_comp_units
.size ());
1579 /* local_type_unit_count - The number of TUs in the local TU
1581 header
.append_uint (4, dwarf5_byte_order
,
1582 dwarf2_per_objfile
->per_bfd
->all_type_units
.size ());
1584 /* foreign_type_unit_count - The number of TUs in the foreign TU
1586 header
.append_uint (4, dwarf5_byte_order
, 0);
1588 /* bucket_count - The number of hash buckets in the hash lookup
1590 header
.append_uint (4, dwarf5_byte_order
, nametable
.bucket_count ());
1592 /* name_count - The number of unique names in the index. */
1593 header
.append_uint (4, dwarf5_byte_order
, nametable
.name_count ());
1595 /* abbrev_table_size - The size in bytes of the abbreviations
1597 header
.append_uint (4, dwarf5_byte_order
, nametable
.abbrev_table_bytes ());
1599 /* augmentation_string_size - The size in bytes of the augmentation
1600 string. This value is rounded up to a multiple of 4. */
1601 static_assert (sizeof (dwarf5_gdb_augmentation
) % 4 == 0, "");
1602 header
.append_uint (4, dwarf5_byte_order
, sizeof (dwarf5_gdb_augmentation
));
1603 header
.append_data (dwarf5_gdb_augmentation
);
1605 gdb_assert (header
.size () == bytes_of_header
);
1607 header
.file_write (out_file
);
1608 cu_list
.file_write (out_file
);
1609 types_cu_list
.file_write (out_file
);
1610 nametable
.file_write (out_file
, out_file_str
);
1612 assert_file_size (out_file
, expected_bytes
);
1615 /* This represents an index file being written (work-in-progress).
1617 The data is initially written to a temporary file. When the finalize method
1618 is called, the file is closed and moved to its final location.
1620 On failure (if this object is being destroyed with having called finalize),
1621 the temporary file is closed and deleted. */
1623 struct index_wip_file
1625 index_wip_file (const char *dir
, const char *basename
,
1628 filename
= (std::string (dir
) + SLASH_STRING
+ basename
1631 filename_temp
= make_temp_filename (filename
);
1633 scoped_fd
out_file_fd (gdb_mkostemp_cloexec (filename_temp
.data (),
1635 if (out_file_fd
.get () == -1)
1636 perror_with_name (("mkstemp"));
1638 out_file
= out_file_fd
.to_file ("wb");
1640 if (out_file
== nullptr)
1641 error (_("Can't open `%s' for writing"), filename_temp
.data ());
1643 unlink_file
.emplace (filename_temp
.data ());
1648 /* We want to keep the file. */
1649 unlink_file
->keep ();
1651 /* Close and move the str file in place. */
1652 unlink_file
.reset ();
1653 if (rename (filename_temp
.data (), filename
.c_str ()) != 0)
1654 perror_with_name (("rename"));
1657 std::string filename
;
1658 gdb::char_vector filename_temp
;
1660 /* Order matters here; we want FILE to be closed before
1661 FILENAME_TEMP is unlinked, because on MS-Windows one cannot
1662 delete a file that is still open. So, we wrap the unlinker in an
1663 optional and emplace it once we know the file name. */
1664 gdb::optional
<gdb::unlinker
> unlink_file
;
1666 gdb_file_up out_file
;
1669 /* See dwarf-index-write.h. */
1672 write_psymtabs_to_index (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
1673 const char *dir
, const char *basename
,
1674 const char *dwz_basename
,
1675 dw_index_kind index_kind
)
1677 struct objfile
*objfile
= dwarf2_per_objfile
->objfile
;
1679 if (dwarf2_per_objfile
->per_bfd
->using_index
)
1680 error (_("Cannot use an index to create the index"));
1682 if (dwarf2_per_objfile
->per_bfd
->types
.size () > 1)
1683 error (_("Cannot make an index when the file has multiple .debug_types sections"));
1685 if (!objfile
->partial_symtabs
->psymtabs
1686 || !objfile
->partial_symtabs
->psymtabs_addrmap
)
1690 if (stat (objfile_name (objfile
), &st
) < 0)
1691 perror_with_name (objfile_name (objfile
));
1693 const char *index_suffix
= (index_kind
== dw_index_kind::DEBUG_NAMES
1694 ? INDEX5_SUFFIX
: INDEX4_SUFFIX
);
1696 index_wip_file
objfile_index_wip (dir
, basename
, index_suffix
);
1697 gdb::optional
<index_wip_file
> dwz_index_wip
;
1699 if (dwz_basename
!= NULL
)
1700 dwz_index_wip
.emplace (dir
, dwz_basename
, index_suffix
);
1702 if (index_kind
== dw_index_kind::DEBUG_NAMES
)
1704 index_wip_file
str_wip_file (dir
, basename
, DEBUG_STR_SUFFIX
);
1706 write_debug_names (dwarf2_per_objfile
, objfile_index_wip
.out_file
.get (),
1707 str_wip_file
.out_file
.get ());
1709 str_wip_file
.finalize ();
1712 write_gdbindex (dwarf2_per_objfile
, objfile_index_wip
.out_file
.get (),
1713 (dwz_index_wip
.has_value ()
1714 ? dwz_index_wip
->out_file
.get () : NULL
));
1716 objfile_index_wip
.finalize ();
1718 if (dwz_index_wip
.has_value ())
1719 dwz_index_wip
->finalize ();
1722 /* Implementation of the `save gdb-index' command.
1724 Note that the .gdb_index file format used by this command is
1725 documented in the GDB manual. Any changes here must be documented
1729 save_gdb_index_command (const char *arg
, int from_tty
)
1731 const char dwarf5space
[] = "-dwarf-5 ";
1732 dw_index_kind index_kind
= dw_index_kind::GDB_INDEX
;
1737 arg
= skip_spaces (arg
);
1738 if (strncmp (arg
, dwarf5space
, strlen (dwarf5space
)) == 0)
1740 index_kind
= dw_index_kind::DEBUG_NAMES
;
1741 arg
+= strlen (dwarf5space
);
1742 arg
= skip_spaces (arg
);
1746 error (_("usage: save gdb-index [-dwarf-5] DIRECTORY"));
1748 for (objfile
*objfile
: current_program_space
->objfiles ())
1752 /* If the objfile does not correspond to an actual file, skip it. */
1753 if (stat (objfile_name (objfile
), &st
) < 0)
1756 struct dwarf2_per_objfile
*dwarf2_per_objfile
1757 = get_dwarf2_per_objfile (objfile
);
1759 if (dwarf2_per_objfile
!= NULL
)
1763 const char *basename
= lbasename (objfile_name (objfile
));
1764 const dwz_file
*dwz
= dwarf2_get_dwz_file (dwarf2_per_objfile
);
1765 const char *dwz_basename
= NULL
;
1768 dwz_basename
= lbasename (dwz
->filename ());
1770 write_psymtabs_to_index (dwarf2_per_objfile
, arg
, basename
,
1771 dwz_basename
, index_kind
);
1773 catch (const gdb_exception_error
&except
)
1775 exception_fprintf (gdb_stderr
, except
,
1776 _("Error while writing index for `%s': "),
1777 objfile_name (objfile
));
1784 void _initialize_dwarf_index_write ();
1786 _initialize_dwarf_index_write ()
1788 cmd_list_element
*c
= add_cmd ("gdb-index", class_files
,
1789 save_gdb_index_command
, _("\
1790 Save a gdb-index file.\n\
1791 Usage: save gdb-index [-dwarf-5] DIRECTORY\n\
1793 No options create one file with .gdb-index extension for pre-DWARF-5\n\
1794 compatible .gdb_index section. With -dwarf-5 creates two files with\n\
1795 extension .debug_names and .debug_str for DWARF-5 .debug_names section."),
1797 set_cmd_completer (c
, filename_completer
);