1 /* DWARF index writing support for GDB.
3 Copyright (C) 1994-2018 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/>. */
23 #include "cli/cli-decode.h"
24 #include "common/byte-vector.h"
25 #include "common/filestuff.h"
26 #include "common/gdb_unlinker.h"
27 #include "complaints.h"
28 #include "dwarf-index-common.h"
30 #include "dwarf2read.h"
31 #include "gdb/gdb-index.h"
39 #include <unordered_map>
40 #include <unordered_set>
42 /* The suffix for an index file. */
43 #define INDEX4_SUFFIX ".gdb-index"
44 #define INDEX5_SUFFIX ".debug_names"
45 #define DEBUG_STR_SUFFIX ".debug_str"
47 /* Ensure only legit values are used. */
48 #define DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE(cu_index, value) \
50 gdb_assert ((unsigned int) (value) <= 1); \
51 GDB_INDEX_SYMBOL_STATIC_SET_VALUE((cu_index), (value)); \
54 /* Ensure only legit values are used. */
55 #define DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE(cu_index, value) \
57 gdb_assert ((value) >= GDB_INDEX_SYMBOL_KIND_TYPE \
58 && (value) <= GDB_INDEX_SYMBOL_KIND_OTHER); \
59 GDB_INDEX_SYMBOL_KIND_SET_VALUE((cu_index), (value)); \
62 /* Ensure we don't use more than the alloted nuber of bits for the CU. */
63 #define DW2_GDB_INDEX_CU_SET_VALUE(cu_index, value) \
65 gdb_assert (((value) & ~GDB_INDEX_CU_MASK) == 0); \
66 GDB_INDEX_CU_SET_VALUE((cu_index), (value)); \
69 /* The "save gdb-index" command. */
71 /* Write SIZE bytes from the buffer pointed to by DATA to FILE, with
75 file_write (FILE *file, const void *data, size_t size)
77 if (fwrite (data, 1, size, file) != size)
78 error (_("couldn't data write to file"));
81 /* Write the contents of VEC to FILE, with error checking. */
83 template<typename Elem, typename Alloc>
85 file_write (FILE *file, const std::vector<Elem, Alloc> &vec)
87 file_write (file, vec.data (), vec.size () * sizeof (vec[0]));
90 /* In-memory buffer to prepare data to be written later to a file. */
94 /* Copy DATA to the end of the buffer. */
96 void append_data (const T &data)
98 std::copy (reinterpret_cast<const gdb_byte *> (&data),
99 reinterpret_cast<const gdb_byte *> (&data + 1),
100 grow (sizeof (data)));
103 /* Copy CSTR (a zero-terminated string) to the end of buffer. The
104 terminating zero is appended too. */
105 void append_cstr0 (const char *cstr)
107 const size_t size = strlen (cstr) + 1;
108 std::copy (cstr, cstr + size, grow (size));
111 /* Store INPUT as ULEB128 to the end of buffer. */
112 void append_unsigned_leb128 (ULONGEST input)
116 gdb_byte output = input & 0x7f;
120 append_data (output);
126 /* Accept a host-format integer in VAL and append it to the buffer
127 as a target-format integer which is LEN bytes long. */
128 void append_uint (size_t len, bfd_endian byte_order, ULONGEST val)
130 ::store_unsigned_integer (grow (len), len, byte_order, val);
133 /* Return the size of the buffer. */
136 return m_vec.size ();
139 /* Return true iff the buffer is empty. */
142 return m_vec.empty ();
145 /* Write the buffer to FILE. */
146 void file_write (FILE *file) const
148 ::file_write (file, m_vec);
152 /* Grow SIZE bytes at the end of the buffer. Returns a pointer to
153 the start of the new block. */
154 gdb_byte *grow (size_t size)
156 m_vec.resize (m_vec.size () + size);
157 return &*m_vec.end () - size;
160 gdb::byte_vector m_vec;
163 /* An entry in the symbol table. */
164 struct symtab_index_entry
166 /* The name of the symbol. */
168 /* The offset of the name in the constant pool. */
169 offset_type index_offset;
170 /* A sorted vector of the indices of all the CUs that hold an object
172 std::vector<offset_type> cu_indices;
175 /* The symbol table. This is a power-of-2-sized hash table. */
183 offset_type n_elements = 0;
184 std::vector<symtab_index_entry> data;
187 /* Find a slot in SYMTAB for the symbol NAME. Returns a reference to
190 Function is used only during write_hash_table so no index format backward
191 compatibility is needed. */
193 static symtab_index_entry &
194 find_slot (struct mapped_symtab *symtab, const char *name)
196 offset_type index, step, hash = mapped_index_string_hash (INT_MAX, name);
198 index = hash & (symtab->data.size () - 1);
199 step = ((hash * 17) & (symtab->data.size () - 1)) | 1;
203 if (symtab->data[index].name == NULL
204 || strcmp (name, symtab->data[index].name) == 0)
205 return symtab->data[index];
206 index = (index + step) & (symtab->data.size () - 1);
210 /* Expand SYMTAB's hash table. */
213 hash_expand (struct mapped_symtab *symtab)
215 auto old_entries = std::move (symtab->data);
217 symtab->data.clear ();
218 symtab->data.resize (old_entries.size () * 2);
220 for (auto &it : old_entries)
223 auto &ref = find_slot (symtab, it.name);
224 ref = std::move (it);
228 /* Add an entry to SYMTAB. NAME is the name of the symbol.
229 CU_INDEX is the index of the CU in which the symbol appears.
230 IS_STATIC is one if the symbol is static, otherwise zero (global). */
233 add_index_entry (struct mapped_symtab *symtab, const char *name,
234 int is_static, gdb_index_symbol_kind kind,
235 offset_type cu_index)
237 offset_type cu_index_and_attrs;
239 ++symtab->n_elements;
240 if (4 * symtab->n_elements / 3 >= symtab->data.size ())
241 hash_expand (symtab);
243 symtab_index_entry &slot = find_slot (symtab, name);
244 if (slot.name == NULL)
247 /* index_offset is set later. */
250 cu_index_and_attrs = 0;
251 DW2_GDB_INDEX_CU_SET_VALUE (cu_index_and_attrs, cu_index);
252 DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE (cu_index_and_attrs, is_static);
253 DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE (cu_index_and_attrs, kind);
255 /* We don't want to record an index value twice as we want to avoid the
257 We process all global symbols and then all static symbols
258 (which would allow us to avoid the duplication by only having to check
259 the last entry pushed), but a symbol could have multiple kinds in one CU.
260 To keep things simple we don't worry about the duplication here and
261 sort and uniqufy the list after we've processed all symbols. */
262 slot.cu_indices.push_back (cu_index_and_attrs);
265 /* Sort and remove duplicates of all symbols' cu_indices lists. */
268 uniquify_cu_indices (struct mapped_symtab *symtab)
270 for (auto &entry : symtab->data)
272 if (entry.name != NULL && !entry.cu_indices.empty ())
274 auto &cu_indices = entry.cu_indices;
275 std::sort (cu_indices.begin (), cu_indices.end ());
276 auto from = std::unique (cu_indices.begin (), cu_indices.end ());
277 cu_indices.erase (from, cu_indices.end ());
282 /* A form of 'const char *' suitable for container keys. Only the
283 pointer is stored. The strings themselves are compared, not the
288 c_str_view (const char *cstr)
292 bool operator== (const c_str_view &other) const
294 return strcmp (m_cstr, other.m_cstr) == 0;
297 /* Return the underlying C string. Note, the returned string is
298 only a reference with lifetime of this object. */
299 const char *c_str () const
305 friend class c_str_view_hasher;
306 const char *const m_cstr;
309 /* A std::unordered_map::hasher for c_str_view that uses the right
310 hash function for strings in a mapped index. */
311 class c_str_view_hasher
314 size_t operator () (const c_str_view &x) const
316 return mapped_index_string_hash (INT_MAX, x.m_cstr);
320 /* A std::unordered_map::hasher for std::vector<>. */
325 size_t operator () (const std::vector<T> &key) const
327 return iterative_hash (key.data (),
328 sizeof (key.front ()) * key.size (), 0);
332 /* Write the mapped hash table SYMTAB to the data buffer OUTPUT, with
333 constant pool entries going into the data buffer CPOOL. */
336 write_hash_table (mapped_symtab *symtab, data_buf &output, data_buf &cpool)
339 /* Elements are sorted vectors of the indices of all the CUs that
340 hold an object of this name. */
341 std::unordered_map<std::vector<offset_type>, offset_type,
342 vector_hasher<offset_type>>
345 /* We add all the index vectors to the constant pool first, to
346 ensure alignment is ok. */
347 for (symtab_index_entry &entry : symtab->data)
349 if (entry.name == NULL)
351 gdb_assert (entry.index_offset == 0);
353 /* Finding before inserting is faster than always trying to
354 insert, because inserting always allocates a node, does the
355 lookup, and then destroys the new node if another node
356 already had the same key. C++17 try_emplace will avoid
359 = symbol_hash_table.find (entry.cu_indices);
360 if (found != symbol_hash_table.end ())
362 entry.index_offset = found->second;
366 symbol_hash_table.emplace (entry.cu_indices, cpool.size ());
367 entry.index_offset = cpool.size ();
368 cpool.append_data (MAYBE_SWAP (entry.cu_indices.size ()));
369 for (const auto index : entry.cu_indices)
370 cpool.append_data (MAYBE_SWAP (index));
374 /* Now write out the hash table. */
375 std::unordered_map<c_str_view, offset_type, c_str_view_hasher> str_table;
376 for (const auto &entry : symtab->data)
378 offset_type str_off, vec_off;
380 if (entry.name != NULL)
382 const auto insertpair = str_table.emplace (entry.name, cpool.size ());
383 if (insertpair.second)
384 cpool.append_cstr0 (entry.name);
385 str_off = insertpair.first->second;
386 vec_off = entry.index_offset;
390 /* While 0 is a valid constant pool index, it is not valid
391 to have 0 for both offsets. */
396 output.append_data (MAYBE_SWAP (str_off));
397 output.append_data (MAYBE_SWAP (vec_off));
401 typedef std::unordered_map<partial_symtab *, unsigned int> psym_index_map;
403 /* Helper struct for building the address table. */
404 struct addrmap_index_data
406 addrmap_index_data (data_buf &addr_vec_, psym_index_map &cu_index_htab_)
407 : addr_vec (addr_vec_), cu_index_htab (cu_index_htab_)
410 struct objfile *objfile;
412 psym_index_map &cu_index_htab;
414 /* Non-zero if the previous_* fields are valid.
415 We can't write an entry until we see the next entry (since it is only then
416 that we know the end of the entry). */
418 /* Index of the CU in the table of all CUs in the index file. */
419 unsigned int previous_cu_index;
420 /* Start address of the CU. */
421 CORE_ADDR previous_cu_start;
424 /* Write an address entry to ADDR_VEC. */
427 add_address_entry (struct objfile *objfile, data_buf &addr_vec,
428 CORE_ADDR start, CORE_ADDR end, unsigned int cu_index)
432 baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
434 addr_vec.append_uint (8, BFD_ENDIAN_LITTLE, start - baseaddr);
435 addr_vec.append_uint (8, BFD_ENDIAN_LITTLE, end - baseaddr);
436 addr_vec.append_data (MAYBE_SWAP (cu_index));
439 /* Worker function for traversing an addrmap to build the address table. */
442 add_address_entry_worker (void *datap, CORE_ADDR start_addr, void *obj)
444 struct addrmap_index_data *data = (struct addrmap_index_data *) datap;
445 struct partial_symtab *pst = (struct partial_symtab *) obj;
447 if (data->previous_valid)
448 add_address_entry (data->objfile, data->addr_vec,
449 data->previous_cu_start, start_addr,
450 data->previous_cu_index);
452 data->previous_cu_start = start_addr;
455 const auto it = data->cu_index_htab.find (pst);
456 gdb_assert (it != data->cu_index_htab.cend ());
457 data->previous_cu_index = it->second;
458 data->previous_valid = 1;
461 data->previous_valid = 0;
466 /* Write OBJFILE's address map to ADDR_VEC.
467 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
468 in the index file. */
471 write_address_map (struct objfile *objfile, data_buf &addr_vec,
472 psym_index_map &cu_index_htab)
474 struct addrmap_index_data addrmap_index_data (addr_vec, cu_index_htab);
476 /* When writing the address table, we have to cope with the fact that
477 the addrmap iterator only provides the start of a region; we have to
478 wait until the next invocation to get the start of the next region. */
480 addrmap_index_data.objfile = objfile;
481 addrmap_index_data.previous_valid = 0;
483 addrmap_foreach (objfile->psymtabs_addrmap, add_address_entry_worker,
484 &addrmap_index_data);
486 /* It's highly unlikely the last entry (end address = 0xff...ff)
487 is valid, but we should still handle it.
488 The end address is recorded as the start of the next region, but that
489 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
491 if (addrmap_index_data.previous_valid)
492 add_address_entry (objfile, addr_vec,
493 addrmap_index_data.previous_cu_start, (CORE_ADDR) -1,
494 addrmap_index_data.previous_cu_index);
497 /* Return the symbol kind of PSYM. */
499 static gdb_index_symbol_kind
500 symbol_kind (struct partial_symbol *psym)
502 domain_enum domain = PSYMBOL_DOMAIN (psym);
503 enum address_class aclass = PSYMBOL_CLASS (psym);
511 return GDB_INDEX_SYMBOL_KIND_FUNCTION;
513 return GDB_INDEX_SYMBOL_KIND_TYPE;
515 case LOC_CONST_BYTES:
516 case LOC_OPTIMIZED_OUT:
518 return GDB_INDEX_SYMBOL_KIND_VARIABLE;
520 /* Note: It's currently impossible to recognize psyms as enum values
521 short of reading the type info. For now punt. */
522 return GDB_INDEX_SYMBOL_KIND_VARIABLE;
524 /* There are other LOC_FOO values that one might want to classify
525 as variables, but dwarf2read.c doesn't currently use them. */
526 return GDB_INDEX_SYMBOL_KIND_OTHER;
529 return GDB_INDEX_SYMBOL_KIND_TYPE;
531 return GDB_INDEX_SYMBOL_KIND_OTHER;
535 /* Add a list of partial symbols to SYMTAB. */
538 write_psymbols (struct mapped_symtab *symtab,
539 std::unordered_set<partial_symbol *> &psyms_seen,
540 struct partial_symbol **psymp,
542 offset_type cu_index,
545 for (; count-- > 0; ++psymp)
547 struct partial_symbol *psym = *psymp;
549 if (SYMBOL_LANGUAGE (psym) == language_ada)
550 error (_("Ada is not currently supported by the index"));
552 /* Only add a given psymbol once. */
553 if (psyms_seen.insert (psym).second)
555 gdb_index_symbol_kind kind = symbol_kind (psym);
557 add_index_entry (symtab, SYMBOL_SEARCH_NAME (psym),
558 is_static, kind, cu_index);
563 /* A helper struct used when iterating over debug_types. */
564 struct signatured_type_index_data
566 signatured_type_index_data (data_buf &types_list_,
567 std::unordered_set<partial_symbol *> &psyms_seen_)
568 : types_list (types_list_), psyms_seen (psyms_seen_)
571 struct objfile *objfile;
572 struct mapped_symtab *symtab;
573 data_buf &types_list;
574 std::unordered_set<partial_symbol *> &psyms_seen;
578 /* A helper function that writes a single signatured_type to an
582 write_one_signatured_type (void **slot, void *d)
584 struct signatured_type_index_data *info
585 = (struct signatured_type_index_data *) d;
586 struct signatured_type *entry = (struct signatured_type *) *slot;
587 struct partial_symtab *psymtab = entry->per_cu.v.psymtab;
589 write_psymbols (info->symtab,
591 &info->objfile->global_psymbols[psymtab->globals_offset],
592 psymtab->n_global_syms, info->cu_index,
594 write_psymbols (info->symtab,
596 &info->objfile->static_psymbols[psymtab->statics_offset],
597 psymtab->n_static_syms, info->cu_index,
600 info->types_list.append_uint (8, BFD_ENDIAN_LITTLE,
601 to_underlying (entry->per_cu.sect_off));
602 info->types_list.append_uint (8, BFD_ENDIAN_LITTLE,
603 to_underlying (entry->type_offset_in_tu));
604 info->types_list.append_uint (8, BFD_ENDIAN_LITTLE, entry->signature);
611 /* Recurse into all "included" dependencies and count their symbols as
612 if they appeared in this psymtab. */
615 recursively_count_psymbols (struct partial_symtab *psymtab,
618 for (int i = 0; i < psymtab->number_of_dependencies; ++i)
619 if (psymtab->dependencies[i]->user != NULL)
620 recursively_count_psymbols (psymtab->dependencies[i],
623 psyms_seen += psymtab->n_global_syms;
624 psyms_seen += psymtab->n_static_syms;
627 /* Recurse into all "included" dependencies and write their symbols as
628 if they appeared in this psymtab. */
631 recursively_write_psymbols (struct objfile *objfile,
632 struct partial_symtab *psymtab,
633 struct mapped_symtab *symtab,
634 std::unordered_set<partial_symbol *> &psyms_seen,
635 offset_type cu_index)
639 for (i = 0; i < psymtab->number_of_dependencies; ++i)
640 if (psymtab->dependencies[i]->user != NULL)
641 recursively_write_psymbols (objfile, psymtab->dependencies[i],
642 symtab, psyms_seen, cu_index);
644 write_psymbols (symtab,
646 &objfile->global_psymbols[psymtab->globals_offset],
647 psymtab->n_global_syms, cu_index,
649 write_psymbols (symtab,
651 &objfile->static_psymbols[psymtab->statics_offset],
652 psymtab->n_static_syms, cu_index,
656 /* DWARF-5 .debug_names builder. */
660 debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile, bool is_dwarf64,
661 bfd_endian dwarf5_byte_order)
662 : m_dwarf5_byte_order (dwarf5_byte_order),
663 m_dwarf32 (dwarf5_byte_order),
664 m_dwarf64 (dwarf5_byte_order),
666 ? static_cast<dwarf &> (m_dwarf64)
667 : static_cast<dwarf &> (m_dwarf32)),
668 m_name_table_string_offs (m_dwarf.name_table_string_offs),
669 m_name_table_entry_offs (m_dwarf.name_table_entry_offs),
670 m_debugstrlookup (dwarf2_per_objfile)
673 int dwarf5_offset_size () const
675 const bool dwarf5_is_dwarf64 = &m_dwarf == &m_dwarf64;
676 return dwarf5_is_dwarf64 ? 8 : 4;
679 /* Is this symbol from DW_TAG_compile_unit or DW_TAG_type_unit? */
680 enum class unit_kind { cu, tu };
682 /* Insert one symbol. */
683 void insert (const partial_symbol *psym, int cu_index, bool is_static,
686 const int dwarf_tag = psymbol_tag (psym);
689 const char *const name = SYMBOL_SEARCH_NAME (psym);
690 const auto insertpair
691 = m_name_to_value_set.emplace (c_str_view (name),
692 std::set<symbol_value> ());
693 std::set<symbol_value> &value_set = insertpair.first->second;
694 value_set.emplace (symbol_value (dwarf_tag, cu_index, is_static, kind));
697 /* Build all the tables. All symbols must be already inserted.
698 This function does not call file_write, caller has to do it
702 /* Verify the build method has not be called twice. */
703 gdb_assert (m_abbrev_table.empty ());
704 const size_t name_count = m_name_to_value_set.size ();
705 m_bucket_table.resize
706 (std::pow (2, std::ceil (std::log2 (name_count * 4 / 3))));
707 m_hash_table.reserve (name_count);
708 m_name_table_string_offs.reserve (name_count);
709 m_name_table_entry_offs.reserve (name_count);
711 /* Map each hash of symbol to its name and value. */
715 decltype (m_name_to_value_set)::const_iterator it;
717 std::vector<std::forward_list<hash_it_pair>> bucket_hash;
718 bucket_hash.resize (m_bucket_table.size ());
719 for (decltype (m_name_to_value_set)::const_iterator it
720 = m_name_to_value_set.cbegin ();
721 it != m_name_to_value_set.cend ();
724 const char *const name = it->first.c_str ();
725 const uint32_t hash = dwarf5_djb_hash (name);
726 hash_it_pair hashitpair;
727 hashitpair.hash = hash;
729 auto &slot = bucket_hash[hash % bucket_hash.size()];
730 slot.push_front (std::move (hashitpair));
732 for (size_t bucket_ix = 0; bucket_ix < bucket_hash.size (); ++bucket_ix)
734 const std::forward_list<hash_it_pair> &hashitlist
735 = bucket_hash[bucket_ix];
736 if (hashitlist.empty ())
738 uint32_t &bucket_slot = m_bucket_table[bucket_ix];
739 /* The hashes array is indexed starting at 1. */
740 store_unsigned_integer (reinterpret_cast<gdb_byte *> (&bucket_slot),
741 sizeof (bucket_slot), m_dwarf5_byte_order,
742 m_hash_table.size () + 1);
743 for (const hash_it_pair &hashitpair : hashitlist)
745 m_hash_table.push_back (0);
746 store_unsigned_integer (reinterpret_cast<gdb_byte *>
747 (&m_hash_table.back ()),
748 sizeof (m_hash_table.back ()),
749 m_dwarf5_byte_order, hashitpair.hash);
750 const c_str_view &name = hashitpair.it->first;
751 const std::set<symbol_value> &value_set = hashitpair.it->second;
752 m_name_table_string_offs.push_back_reorder
753 (m_debugstrlookup.lookup (name.c_str ()));
754 m_name_table_entry_offs.push_back_reorder (m_entry_pool.size ());
755 gdb_assert (!value_set.empty ());
756 for (const symbol_value &value : value_set)
758 int &idx = m_indexkey_to_idx[index_key (value.dwarf_tag,
764 m_abbrev_table.append_unsigned_leb128 (idx);
765 m_abbrev_table.append_unsigned_leb128 (value.dwarf_tag);
766 m_abbrev_table.append_unsigned_leb128
767 (value.kind == unit_kind::cu ? DW_IDX_compile_unit
769 m_abbrev_table.append_unsigned_leb128 (DW_FORM_udata);
770 m_abbrev_table.append_unsigned_leb128 (value.is_static
771 ? DW_IDX_GNU_internal
772 : DW_IDX_GNU_external);
773 m_abbrev_table.append_unsigned_leb128 (DW_FORM_flag_present);
775 /* Terminate attributes list. */
776 m_abbrev_table.append_unsigned_leb128 (0);
777 m_abbrev_table.append_unsigned_leb128 (0);
780 m_entry_pool.append_unsigned_leb128 (idx);
781 m_entry_pool.append_unsigned_leb128 (value.cu_index);
784 /* Terminate the list of CUs. */
785 m_entry_pool.append_unsigned_leb128 (0);
788 gdb_assert (m_hash_table.size () == name_count);
790 /* Terminate tags list. */
791 m_abbrev_table.append_unsigned_leb128 (0);
794 /* Return .debug_names bucket count. This must be called only after
795 calling the build method. */
796 uint32_t bucket_count () const
798 /* Verify the build method has been already called. */
799 gdb_assert (!m_abbrev_table.empty ());
800 const uint32_t retval = m_bucket_table.size ();
802 /* Check for overflow. */
803 gdb_assert (retval == m_bucket_table.size ());
807 /* Return .debug_names names count. This must be called only after
808 calling the build method. */
809 uint32_t name_count () const
811 /* Verify the build method has been already called. */
812 gdb_assert (!m_abbrev_table.empty ());
813 const uint32_t retval = m_hash_table.size ();
815 /* Check for overflow. */
816 gdb_assert (retval == m_hash_table.size ());
820 /* Return number of bytes of .debug_names abbreviation table. This
821 must be called only after calling the build method. */
822 uint32_t abbrev_table_bytes () const
824 gdb_assert (!m_abbrev_table.empty ());
825 return m_abbrev_table.size ();
828 /* Recurse into all "included" dependencies and store their symbols
829 as if they appeared in this psymtab. */
830 void recursively_write_psymbols
831 (struct objfile *objfile,
832 struct partial_symtab *psymtab,
833 std::unordered_set<partial_symbol *> &psyms_seen,
836 for (int i = 0; i < psymtab->number_of_dependencies; ++i)
837 if (psymtab->dependencies[i]->user != NULL)
838 recursively_write_psymbols (objfile, psymtab->dependencies[i],
839 psyms_seen, cu_index);
841 write_psymbols (psyms_seen,
842 &objfile->global_psymbols[psymtab->globals_offset],
843 psymtab->n_global_syms, cu_index, false, unit_kind::cu);
844 write_psymbols (psyms_seen,
845 &objfile->static_psymbols[psymtab->statics_offset],
846 psymtab->n_static_syms, cu_index, true, unit_kind::cu);
849 /* Return number of bytes the .debug_names section will have. This
850 must be called only after calling the build method. */
851 size_t bytes () const
853 /* Verify the build method has been already called. */
854 gdb_assert (!m_abbrev_table.empty ());
855 size_t expected_bytes = 0;
856 expected_bytes += m_bucket_table.size () * sizeof (m_bucket_table[0]);
857 expected_bytes += m_hash_table.size () * sizeof (m_hash_table[0]);
858 expected_bytes += m_name_table_string_offs.bytes ();
859 expected_bytes += m_name_table_entry_offs.bytes ();
860 expected_bytes += m_abbrev_table.size ();
861 expected_bytes += m_entry_pool.size ();
862 return expected_bytes;
865 /* Write .debug_names to FILE_NAMES and .debug_str addition to
866 FILE_STR. This must be called only after calling the build
868 void file_write (FILE *file_names, FILE *file_str) const
870 /* Verify the build method has been already called. */
871 gdb_assert (!m_abbrev_table.empty ());
872 ::file_write (file_names, m_bucket_table);
873 ::file_write (file_names, m_hash_table);
874 m_name_table_string_offs.file_write (file_names);
875 m_name_table_entry_offs.file_write (file_names);
876 m_abbrev_table.file_write (file_names);
877 m_entry_pool.file_write (file_names);
878 m_debugstrlookup.file_write (file_str);
881 /* A helper user data for write_one_signatured_type. */
882 class write_one_signatured_type_data
885 write_one_signatured_type_data (debug_names &nametable_,
886 signatured_type_index_data &&info_)
887 : nametable (nametable_), info (std::move (info_))
889 debug_names &nametable;
890 struct signatured_type_index_data info;
893 /* A helper function to pass write_one_signatured_type to
894 htab_traverse_noresize. */
896 write_one_signatured_type (void **slot, void *d)
898 write_one_signatured_type_data *data = (write_one_signatured_type_data *) d;
899 struct signatured_type_index_data *info = &data->info;
900 struct signatured_type *entry = (struct signatured_type *) *slot;
902 data->nametable.write_one_signatured_type (entry, info);
909 /* Storage for symbol names mapping them to their .debug_str section
911 class debug_str_lookup
915 /* Object costructor to be called for current DWARF2_PER_OBJFILE.
916 All .debug_str section strings are automatically stored. */
917 debug_str_lookup (struct dwarf2_per_objfile *dwarf2_per_objfile)
918 : m_abfd (dwarf2_per_objfile->objfile->obfd),
919 m_dwarf2_per_objfile (dwarf2_per_objfile)
921 dwarf2_read_section (dwarf2_per_objfile->objfile,
922 &dwarf2_per_objfile->str);
923 if (dwarf2_per_objfile->str.buffer == NULL)
925 for (const gdb_byte *data = dwarf2_per_objfile->str.buffer;
926 data < (dwarf2_per_objfile->str.buffer
927 + dwarf2_per_objfile->str.size);)
929 const char *const s = reinterpret_cast<const char *> (data);
930 const auto insertpair
931 = m_str_table.emplace (c_str_view (s),
932 data - dwarf2_per_objfile->str.buffer);
933 if (!insertpair.second)
934 complaint (&symfile_complaints,
935 _("Duplicate string \"%s\" in "
936 ".debug_str section [in module %s]"),
937 s, bfd_get_filename (m_abfd));
938 data += strlen (s) + 1;
942 /* Return offset of symbol name S in the .debug_str section. Add
943 such symbol to the section's end if it does not exist there
945 size_t lookup (const char *s)
947 const auto it = m_str_table.find (c_str_view (s));
948 if (it != m_str_table.end ())
950 const size_t offset = (m_dwarf2_per_objfile->str.size
951 + m_str_add_buf.size ());
952 m_str_table.emplace (c_str_view (s), offset);
953 m_str_add_buf.append_cstr0 (s);
957 /* Append the end of the .debug_str section to FILE. */
958 void file_write (FILE *file) const
960 m_str_add_buf.file_write (file);
964 std::unordered_map<c_str_view, size_t, c_str_view_hasher> m_str_table;
966 struct dwarf2_per_objfile *m_dwarf2_per_objfile;
968 /* Data to add at the end of .debug_str for new needed symbol names. */
969 data_buf m_str_add_buf;
972 /* Container to map used DWARF tags to their .debug_names abbreviation
977 index_key (int dwarf_tag_, bool is_static_, unit_kind kind_)
978 : dwarf_tag (dwarf_tag_), is_static (is_static_), kind (kind_)
983 operator== (const index_key &other) const
985 return (dwarf_tag == other.dwarf_tag && is_static == other.is_static
986 && kind == other.kind);
990 const bool is_static;
991 const unit_kind kind;
994 /* Provide std::unordered_map::hasher for index_key. */
995 class index_key_hasher
999 operator () (const index_key &key) const
1001 return (std::hash<int>() (key.dwarf_tag) << 1) | key.is_static;
1005 /* Parameters of one symbol entry. */
1009 const int dwarf_tag, cu_index;
1010 const bool is_static;
1011 const unit_kind kind;
1013 symbol_value (int dwarf_tag_, int cu_index_, bool is_static_,
1015 : dwarf_tag (dwarf_tag_), cu_index (cu_index_), is_static (is_static_),
1020 operator< (const symbol_value &other) const
1040 /* Abstract base class to unify DWARF-32 and DWARF-64 name table
1045 const bfd_endian dwarf5_byte_order;
1047 explicit offset_vec (bfd_endian dwarf5_byte_order_)
1048 : dwarf5_byte_order (dwarf5_byte_order_)
1051 /* Call std::vector::reserve for NELEM elements. */
1052 virtual void reserve (size_t nelem) = 0;
1054 /* Call std::vector::push_back with store_unsigned_integer byte
1055 reordering for ELEM. */
1056 virtual void push_back_reorder (size_t elem) = 0;
1058 /* Return expected output size in bytes. */
1059 virtual size_t bytes () const = 0;
1061 /* Write name table to FILE. */
1062 virtual void file_write (FILE *file) const = 0;
1065 /* Template to unify DWARF-32 and DWARF-64 output. */
1066 template<typename OffsetSize>
1067 class offset_vec_tmpl : public offset_vec
1070 explicit offset_vec_tmpl (bfd_endian dwarf5_byte_order_)
1071 : offset_vec (dwarf5_byte_order_)
1074 /* Implement offset_vec::reserve. */
1075 void reserve (size_t nelem) override
1077 m_vec.reserve (nelem);
1080 /* Implement offset_vec::push_back_reorder. */
1081 void push_back_reorder (size_t elem) override
1083 m_vec.push_back (elem);
1084 /* Check for overflow. */
1085 gdb_assert (m_vec.back () == elem);
1086 store_unsigned_integer (reinterpret_cast<gdb_byte *> (&m_vec.back ()),
1087 sizeof (m_vec.back ()), dwarf5_byte_order, elem);
1090 /* Implement offset_vec::bytes. */
1091 size_t bytes () const override
1093 return m_vec.size () * sizeof (m_vec[0]);
1096 /* Implement offset_vec::file_write. */
1097 void file_write (FILE *file) const override
1099 ::file_write (file, m_vec);
1103 std::vector<OffsetSize> m_vec;
1106 /* Base class to unify DWARF-32 and DWARF-64 .debug_names output
1107 respecting name table width. */
1111 offset_vec &name_table_string_offs, &name_table_entry_offs;
1113 dwarf (offset_vec &name_table_string_offs_,
1114 offset_vec &name_table_entry_offs_)
1115 : name_table_string_offs (name_table_string_offs_),
1116 name_table_entry_offs (name_table_entry_offs_)
1121 /* Template to unify DWARF-32 and DWARF-64 .debug_names output
1122 respecting name table width. */
1123 template<typename OffsetSize>
1124 class dwarf_tmpl : public dwarf
1127 explicit dwarf_tmpl (bfd_endian dwarf5_byte_order_)
1128 : dwarf (m_name_table_string_offs, m_name_table_entry_offs),
1129 m_name_table_string_offs (dwarf5_byte_order_),
1130 m_name_table_entry_offs (dwarf5_byte_order_)
1134 offset_vec_tmpl<OffsetSize> m_name_table_string_offs;
1135 offset_vec_tmpl<OffsetSize> m_name_table_entry_offs;
1138 /* Try to reconstruct original DWARF tag for given partial_symbol.
1139 This function is not DWARF-5 compliant but it is sufficient for
1140 GDB as a DWARF-5 index consumer. */
1141 static int psymbol_tag (const struct partial_symbol *psym)
1143 domain_enum domain = PSYMBOL_DOMAIN (psym);
1144 enum address_class aclass = PSYMBOL_CLASS (psym);
1152 return DW_TAG_subprogram;
1154 return DW_TAG_typedef;
1156 case LOC_CONST_BYTES:
1157 case LOC_OPTIMIZED_OUT:
1159 return DW_TAG_variable;
1161 /* Note: It's currently impossible to recognize psyms as enum values
1162 short of reading the type info. For now punt. */
1163 return DW_TAG_variable;
1165 /* There are other LOC_FOO values that one might want to classify
1166 as variables, but dwarf2read.c doesn't currently use them. */
1167 return DW_TAG_variable;
1170 return DW_TAG_structure_type;
1176 /* Call insert for all partial symbols and mark them in PSYMS_SEEN. */
1177 void write_psymbols (std::unordered_set<partial_symbol *> &psyms_seen,
1178 struct partial_symbol **psymp, int count, int cu_index,
1179 bool is_static, unit_kind kind)
1181 for (; count-- > 0; ++psymp)
1183 struct partial_symbol *psym = *psymp;
1185 if (SYMBOL_LANGUAGE (psym) == language_ada)
1186 error (_("Ada is not currently supported by the index"));
1188 /* Only add a given psymbol once. */
1189 if (psyms_seen.insert (psym).second)
1190 insert (psym, cu_index, is_static, kind);
1194 /* A helper function that writes a single signatured_type
1195 to a debug_names. */
1197 write_one_signatured_type (struct signatured_type *entry,
1198 struct signatured_type_index_data *info)
1200 struct partial_symtab *psymtab = entry->per_cu.v.psymtab;
1202 write_psymbols (info->psyms_seen,
1203 &info->objfile->global_psymbols[psymtab->globals_offset],
1204 psymtab->n_global_syms, info->cu_index, false,
1206 write_psymbols (info->psyms_seen,
1207 &info->objfile->static_psymbols[psymtab->statics_offset],
1208 psymtab->n_static_syms, info->cu_index, true,
1211 info->types_list.append_uint (dwarf5_offset_size (), m_dwarf5_byte_order,
1212 to_underlying (entry->per_cu.sect_off));
1217 /* Store value of each symbol. */
1218 std::unordered_map<c_str_view, std::set<symbol_value>, c_str_view_hasher>
1219 m_name_to_value_set;
1221 /* Tables of DWARF-5 .debug_names. They are in object file byte
1223 std::vector<uint32_t> m_bucket_table;
1224 std::vector<uint32_t> m_hash_table;
1226 const bfd_endian m_dwarf5_byte_order;
1227 dwarf_tmpl<uint32_t> m_dwarf32;
1228 dwarf_tmpl<uint64_t> m_dwarf64;
1230 offset_vec &m_name_table_string_offs, &m_name_table_entry_offs;
1231 debug_str_lookup m_debugstrlookup;
1233 /* Map each used .debug_names abbreviation tag parameter to its
1235 std::unordered_map<index_key, int, index_key_hasher> m_indexkey_to_idx;
1237 /* Next unused .debug_names abbreviation tag for
1238 m_indexkey_to_idx. */
1241 /* .debug_names abbreviation table. */
1242 data_buf m_abbrev_table;
1244 /* .debug_names entry pool. */
1245 data_buf m_entry_pool;
1248 /* Return iff any of the needed offsets does not fit into 32-bit
1249 .debug_names section. */
1252 check_dwarf64_offsets (struct dwarf2_per_objfile *dwarf2_per_objfile)
1254 for (int i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
1256 const dwarf2_per_cu_data &per_cu = *dwarf2_per_objfile->all_comp_units[i];
1258 if (to_underlying (per_cu.sect_off) >= (static_cast<uint64_t> (1) << 32))
1261 for (int i = 0; i < dwarf2_per_objfile->n_type_units; ++i)
1263 const signatured_type &sigtype = *dwarf2_per_objfile->all_type_units[i];
1264 const dwarf2_per_cu_data &per_cu = sigtype.per_cu;
1266 if (to_underlying (per_cu.sect_off) >= (static_cast<uint64_t> (1) << 32))
1272 /* The psyms_seen set is potentially going to be largish (~40k
1273 elements when indexing a -g3 build of GDB itself). Estimate the
1274 number of elements in order to avoid too many rehashes, which
1275 require rebuilding buckets and thus many trips to
1279 psyms_seen_size (struct dwarf2_per_objfile *dwarf2_per_objfile)
1281 size_t psyms_count = 0;
1282 for (int i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
1284 struct dwarf2_per_cu_data *per_cu
1285 = dwarf2_per_objfile->all_comp_units[i];
1286 struct partial_symtab *psymtab = per_cu->v.psymtab;
1288 if (psymtab != NULL && psymtab->user == NULL)
1289 recursively_count_psymbols (psymtab, psyms_count);
1291 /* Generating an index for gdb itself shows a ratio of
1292 TOTAL_SEEN_SYMS/UNIQUE_SYMS or ~5. 4 seems like a good bet. */
1293 return psyms_count / 4;
1296 /* Write new .gdb_index section for OBJFILE into OUT_FILE.
1297 Return how many bytes were expected to be written into OUT_FILE. */
1300 write_gdbindex (struct dwarf2_per_objfile *dwarf2_per_objfile, FILE *out_file)
1302 struct objfile *objfile = dwarf2_per_objfile->objfile;
1303 mapped_symtab symtab;
1306 /* While we're scanning CU's create a table that maps a psymtab pointer
1307 (which is what addrmap records) to its index (which is what is recorded
1308 in the index file). This will later be needed to write the address
1310 psym_index_map cu_index_htab;
1311 cu_index_htab.reserve (dwarf2_per_objfile->n_comp_units);
1313 /* The CU list is already sorted, so we don't need to do additional
1314 work here. Also, the debug_types entries do not appear in
1315 all_comp_units, but only in their own hash table. */
1317 std::unordered_set<partial_symbol *> psyms_seen
1318 (psyms_seen_size (dwarf2_per_objfile));
1319 for (int i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
1321 struct dwarf2_per_cu_data *per_cu
1322 = dwarf2_per_objfile->all_comp_units[i];
1323 struct partial_symtab *psymtab = per_cu->v.psymtab;
1325 /* CU of a shared file from 'dwz -m' may be unused by this main file.
1326 It may be referenced from a local scope but in such case it does not
1327 need to be present in .gdb_index. */
1328 if (psymtab == NULL)
1331 if (psymtab->user == NULL)
1332 recursively_write_psymbols (objfile, psymtab, &symtab,
1335 const auto insertpair = cu_index_htab.emplace (psymtab, i);
1336 gdb_assert (insertpair.second);
1338 cu_list.append_uint (8, BFD_ENDIAN_LITTLE,
1339 to_underlying (per_cu->sect_off));
1340 cu_list.append_uint (8, BFD_ENDIAN_LITTLE, per_cu->length);
1343 /* Dump the address map. */
1345 write_address_map (objfile, addr_vec, cu_index_htab);
1347 /* Write out the .debug_type entries, if any. */
1348 data_buf types_cu_list;
1349 if (dwarf2_per_objfile->signatured_types)
1351 signatured_type_index_data sig_data (types_cu_list,
1354 sig_data.objfile = objfile;
1355 sig_data.symtab = &symtab;
1356 sig_data.cu_index = dwarf2_per_objfile->n_comp_units;
1357 htab_traverse_noresize (dwarf2_per_objfile->signatured_types,
1358 write_one_signatured_type, &sig_data);
1361 /* Now that we've processed all symbols we can shrink their cu_indices
1363 uniquify_cu_indices (&symtab);
1365 data_buf symtab_vec, constant_pool;
1366 write_hash_table (&symtab, symtab_vec, constant_pool);
1369 const offset_type size_of_contents = 6 * sizeof (offset_type);
1370 offset_type total_len = size_of_contents;
1372 /* The version number. */
1373 contents.append_data (MAYBE_SWAP (8));
1375 /* The offset of the CU list from the start of the file. */
1376 contents.append_data (MAYBE_SWAP (total_len));
1377 total_len += cu_list.size ();
1379 /* The offset of the types CU list from the start of the file. */
1380 contents.append_data (MAYBE_SWAP (total_len));
1381 total_len += types_cu_list.size ();
1383 /* The offset of the address table from the start of the file. */
1384 contents.append_data (MAYBE_SWAP (total_len));
1385 total_len += addr_vec.size ();
1387 /* The offset of the symbol table from the start of the file. */
1388 contents.append_data (MAYBE_SWAP (total_len));
1389 total_len += symtab_vec.size ();
1391 /* The offset of the constant pool from the start of the file. */
1392 contents.append_data (MAYBE_SWAP (total_len));
1393 total_len += constant_pool.size ();
1395 gdb_assert (contents.size () == size_of_contents);
1397 contents.file_write (out_file);
1398 cu_list.file_write (out_file);
1399 types_cu_list.file_write (out_file);
1400 addr_vec.file_write (out_file);
1401 symtab_vec.file_write (out_file);
1402 constant_pool.file_write (out_file);
1407 /* DWARF-5 augmentation string for GDB's DW_IDX_GNU_* extension. */
1408 static const gdb_byte dwarf5_gdb_augmentation[] = { 'G', 'D', 'B', 0 };
1410 /* Write a new .debug_names section for OBJFILE into OUT_FILE, write
1411 needed addition to .debug_str section to OUT_FILE_STR. Return how
1412 many bytes were expected to be written into OUT_FILE. */
1415 write_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile,
1416 FILE *out_file, FILE *out_file_str)
1418 const bool dwarf5_is_dwarf64 = check_dwarf64_offsets (dwarf2_per_objfile);
1419 struct objfile *objfile = dwarf2_per_objfile->objfile;
1420 const enum bfd_endian dwarf5_byte_order
1421 = gdbarch_byte_order (get_objfile_arch (objfile));
1423 /* The CU list is already sorted, so we don't need to do additional
1424 work here. Also, the debug_types entries do not appear in
1425 all_comp_units, but only in their own hash table. */
1427 debug_names nametable (dwarf2_per_objfile, dwarf5_is_dwarf64,
1429 std::unordered_set<partial_symbol *>
1430 psyms_seen (psyms_seen_size (dwarf2_per_objfile));
1431 for (int i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
1433 const dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->all_comp_units[i];
1434 partial_symtab *psymtab = per_cu->v.psymtab;
1436 /* CU of a shared file from 'dwz -m' may be unused by this main
1437 file. It may be referenced from a local scope but in such
1438 case it does not need to be present in .debug_names. */
1439 if (psymtab == NULL)
1442 if (psymtab->user == NULL)
1443 nametable.recursively_write_psymbols (objfile, psymtab, psyms_seen, i);
1445 cu_list.append_uint (nametable.dwarf5_offset_size (), dwarf5_byte_order,
1446 to_underlying (per_cu->sect_off));
1449 /* Write out the .debug_type entries, if any. */
1450 data_buf types_cu_list;
1451 if (dwarf2_per_objfile->signatured_types)
1453 debug_names::write_one_signatured_type_data sig_data (nametable,
1454 signatured_type_index_data (types_cu_list, psyms_seen));
1456 sig_data.info.objfile = objfile;
1457 /* It is used only for gdb_index. */
1458 sig_data.info.symtab = nullptr;
1459 sig_data.info.cu_index = 0;
1460 htab_traverse_noresize (dwarf2_per_objfile->signatured_types,
1461 debug_names::write_one_signatured_type,
1467 /* No addr_vec - DWARF-5 uses .debug_aranges generated by GCC. */
1469 const offset_type bytes_of_header
1470 = ((dwarf5_is_dwarf64 ? 12 : 4)
1472 + sizeof (dwarf5_gdb_augmentation));
1473 size_t expected_bytes = 0;
1474 expected_bytes += bytes_of_header;
1475 expected_bytes += cu_list.size ();
1476 expected_bytes += types_cu_list.size ();
1477 expected_bytes += nametable.bytes ();
1480 if (!dwarf5_is_dwarf64)
1482 const uint64_t size64 = expected_bytes - 4;
1483 gdb_assert (size64 < 0xfffffff0);
1484 header.append_uint (4, dwarf5_byte_order, size64);
1488 header.append_uint (4, dwarf5_byte_order, 0xffffffff);
1489 header.append_uint (8, dwarf5_byte_order, expected_bytes - 12);
1492 /* The version number. */
1493 header.append_uint (2, dwarf5_byte_order, 5);
1496 header.append_uint (2, dwarf5_byte_order, 0);
1498 /* comp_unit_count - The number of CUs in the CU list. */
1499 header.append_uint (4, dwarf5_byte_order, dwarf2_per_objfile->n_comp_units);
1501 /* local_type_unit_count - The number of TUs in the local TU
1503 header.append_uint (4, dwarf5_byte_order, dwarf2_per_objfile->n_type_units);
1505 /* foreign_type_unit_count - The number of TUs in the foreign TU
1507 header.append_uint (4, dwarf5_byte_order, 0);
1509 /* bucket_count - The number of hash buckets in the hash lookup
1511 header.append_uint (4, dwarf5_byte_order, nametable.bucket_count ());
1513 /* name_count - The number of unique names in the index. */
1514 header.append_uint (4, dwarf5_byte_order, nametable.name_count ());
1516 /* abbrev_table_size - The size in bytes of the abbreviations
1518 header.append_uint (4, dwarf5_byte_order, nametable.abbrev_table_bytes ());
1520 /* augmentation_string_size - The size in bytes of the augmentation
1521 string. This value is rounded up to a multiple of 4. */
1522 static_assert (sizeof (dwarf5_gdb_augmentation) % 4 == 0, "");
1523 header.append_uint (4, dwarf5_byte_order, sizeof (dwarf5_gdb_augmentation));
1524 header.append_data (dwarf5_gdb_augmentation);
1526 gdb_assert (header.size () == bytes_of_header);
1528 header.file_write (out_file);
1529 cu_list.file_write (out_file);
1530 types_cu_list.file_write (out_file);
1531 nametable.file_write (out_file, out_file_str);
1533 return expected_bytes;
1536 /* Assert that FILE's size is EXPECTED_SIZE. Assumes file's seek
1537 position is at the end of the file. */
1540 assert_file_size (FILE *file, const char *filename, size_t expected_size)
1542 const auto file_size = ftell (file);
1543 if (file_size == -1)
1544 error (_("Can't get `%s' size"), filename);
1545 gdb_assert (file_size == expected_size);
1548 /* Create an index file for OBJFILE in the directory DIR. */
1551 write_psymtabs_to_index (struct dwarf2_per_objfile *dwarf2_per_objfile,
1553 dw_index_kind index_kind)
1555 struct objfile *objfile = dwarf2_per_objfile->objfile;
1557 if (dwarf2_per_objfile->using_index)
1558 error (_("Cannot use an index to create the index"));
1560 if (VEC_length (dwarf2_section_info_def, dwarf2_per_objfile->types) > 1)
1561 error (_("Cannot make an index when the file has multiple .debug_types sections"));
1563 if (!objfile->psymtabs || !objfile->psymtabs_addrmap)
1567 if (stat (objfile_name (objfile), &st) < 0)
1568 perror_with_name (objfile_name (objfile));
1570 std::string filename (std::string (dir) + SLASH_STRING
1571 + lbasename (objfile_name (objfile))
1572 + (index_kind == dw_index_kind::DEBUG_NAMES
1573 ? INDEX5_SUFFIX : INDEX4_SUFFIX));
1575 FILE *out_file = gdb_fopen_cloexec (filename.c_str (), "wb").release ();
1577 error (_("Can't open `%s' for writing"), filename.c_str ());
1579 /* Order matters here; we want FILE to be closed before FILENAME is
1580 unlinked, because on MS-Windows one cannot delete a file that is
1581 still open. (Don't call anything here that might throw until
1582 file_closer is created.) */
1583 gdb::unlinker unlink_file (filename.c_str ());
1584 gdb_file_up close_out_file (out_file);
1586 if (index_kind == dw_index_kind::DEBUG_NAMES)
1588 std::string filename_str (std::string (dir) + SLASH_STRING
1589 + lbasename (objfile_name (objfile))
1590 + DEBUG_STR_SUFFIX);
1592 = gdb_fopen_cloexec (filename_str.c_str (), "wb").release ();
1594 error (_("Can't open `%s' for writing"), filename_str.c_str ());
1595 gdb::unlinker unlink_file_str (filename_str.c_str ());
1596 gdb_file_up close_out_file_str (out_file_str);
1598 const size_t total_len
1599 = write_debug_names (dwarf2_per_objfile, out_file, out_file_str);
1600 assert_file_size (out_file, filename.c_str (), total_len);
1602 /* We want to keep the file .debug_str file too. */
1603 unlink_file_str.keep ();
1607 const size_t total_len
1608 = write_gdbindex (dwarf2_per_objfile, out_file);
1609 assert_file_size (out_file, filename.c_str (), total_len);
1612 /* We want to keep the file. */
1613 unlink_file.keep ();
1616 /* Implementation of the `save gdb-index' command.
1618 Note that the .gdb_index file format used by this command is
1619 documented in the GDB manual. Any changes here must be documented
1623 save_gdb_index_command (const char *arg, int from_tty)
1625 struct objfile *objfile;
1626 const char dwarf5space[] = "-dwarf-5 ";
1627 dw_index_kind index_kind = dw_index_kind::GDB_INDEX;
1632 arg = skip_spaces (arg);
1633 if (strncmp (arg, dwarf5space, strlen (dwarf5space)) == 0)
1635 index_kind = dw_index_kind::DEBUG_NAMES;
1636 arg += strlen (dwarf5space);
1637 arg = skip_spaces (arg);
1641 error (_("usage: save gdb-index [-dwarf-5] DIRECTORY"));
1643 ALL_OBJFILES (objfile)
1647 /* If the objfile does not correspond to an actual file, skip it. */
1648 if (stat (objfile_name (objfile), &st) < 0)
1651 struct dwarf2_per_objfile *dwarf2_per_objfile
1652 = get_dwarf2_per_objfile (objfile);
1654 if (dwarf2_per_objfile != NULL)
1658 write_psymtabs_to_index (dwarf2_per_objfile, arg, index_kind);
1660 CATCH (except, RETURN_MASK_ERROR)
1662 exception_fprintf (gdb_stderr, except,
1663 _("Error while writing index for `%s': "),
1664 objfile_name (objfile));
1673 _initialize_dwarf_index_write ()
1675 cmd_list_element *c = add_cmd ("gdb-index", class_files,
1676 save_gdb_index_command, _("\
1677 Save a gdb-index file.\n\
1678 Usage: save gdb-index [-dwarf-5] DIRECTORY\n\
1680 No options create one file with .gdb-index extension for pre-DWARF-5\n\
1681 compatible .gdb_index section. With -dwarf-5 creates two files with\n\
1682 extension .debug_names and .debug_str for DWARF-5 .debug_names section."),
1684 set_cmd_completer (c, filename_completer);