GDB (xrefs)
Loading...
Searching...
No Matches
index-write.c
Go to the documentation of this file.
1/* DWARF index writing support for GDB.
2
3 Copyright (C) 1994-2023 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20#include "defs.h"
21
22#include "dwarf2/index-write.h"
23
24#include "addrmap.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"
33#include "dwarf2.h"
34#include "dwarf2/read.h"
35#include "dwarf2/dwz.h"
36#include "gdb/gdb-index.h"
37#include "gdbcmd.h"
38#include "objfiles.h"
39#include "ada-lang.h"
40#include "dwarf2/tag.h"
41
42#include <algorithm>
43#include <cmath>
44#include <forward_list>
45#include <set>
46#include <unordered_map>
47#include <unordered_set>
48
49/* Ensure only legit values are used. */
50#define DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE(cu_index, value) \
51 do { \
52 gdb_assert ((unsigned int) (value) <= 1); \
53 GDB_INDEX_SYMBOL_STATIC_SET_VALUE((cu_index), (value)); \
54 } while (0)
55
56/* Ensure only legit values are used. */
57#define DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE(cu_index, value) \
58 do { \
59 gdb_assert ((value) >= GDB_INDEX_SYMBOL_KIND_TYPE \
60 && (value) <= GDB_INDEX_SYMBOL_KIND_OTHER); \
61 GDB_INDEX_SYMBOL_KIND_SET_VALUE((cu_index), (value)); \
62 } while (0)
63
64/* Ensure we don't use more than the allotted number of bits for the CU. */
65#define DW2_GDB_INDEX_CU_SET_VALUE(cu_index, value) \
66 do { \
67 gdb_assert (((value) & ~GDB_INDEX_CU_MASK) == 0); \
68 GDB_INDEX_CU_SET_VALUE((cu_index), (value)); \
69 } while (0)
70
71/* The "save gdb-index" command. */
72
73/* Write SIZE bytes from the buffer pointed to by DATA to FILE, with
74 error checking. */
75
76static void
77file_write (FILE *file, const void *data, size_t size)
78{
79 if (fwrite (data, 1, size, file) != size)
80 error (_("couldn't data write to file"));
81}
82
83/* Write the contents of VEC to FILE, with error checking. */
84
85template<typename Elem, typename Alloc>
86static void
87file_write (FILE *file, const std::vector<Elem, Alloc> &vec)
88{
89 if (!vec.empty ())
90 file_write (file, vec.data (), vec.size () * sizeof (vec[0]));
91}
92
93/* In-memory buffer to prepare data to be written later to a file. */
95{
96public:
97 /* Copy ARRAY to the end of the buffer. */
98 void append_array (gdb::array_view<const gdb_byte> array)
99 {
100 std::copy (array.begin (), array.end (), grow (array.size ()));
101 }
102
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)
106 {
107 const size_t size = strlen (cstr) + 1;
108 std::copy (cstr, cstr + size, grow (size));
109 }
110
111 /* Store INPUT as ULEB128 to the end of buffer. */
112 void append_unsigned_leb128 (ULONGEST input)
113 {
114 for (;;)
115 {
116 gdb_byte output = input & 0x7f;
117 input >>= 7;
118 if (input)
119 output |= 0x80;
120 m_vec.push_back (output);
121 if (input == 0)
122 break;
123 }
124 }
125
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)
129 {
130 ::store_unsigned_integer (grow (len), len, byte_order, val);
131 }
132
133 /* Copy VALUE to the end of the buffer, little-endian. */
135 {
136 append_uint (sizeof (value), BFD_ENDIAN_LITTLE, value);
137 }
138
139 /* Return the size of the buffer. */
140 size_t size () const
141 {
142 return m_vec.size ();
143 }
144
145 /* Return true iff the buffer is empty. */
146 bool empty () const
147 {
148 return m_vec.empty ();
149 }
150
151 /* Write the buffer to FILE. */
152 void file_write (FILE *file) const
153 {
154 ::file_write (file, m_vec);
155 }
156
157private:
158 /* Grow SIZE bytes at the end of the buffer. Returns a pointer to
159 the start of the new block. */
160 gdb_byte *grow (size_t size)
161 {
162 m_vec.resize (m_vec.size () + size);
163 return &*(m_vec.end () - size);
164 }
165
166 gdb::byte_vector m_vec;
167};
168
169/* An entry in the symbol table. */
171{
172 /* The name of the symbol. */
173 const char *name;
174 /* The offset of the name in the constant pool. */
176 /* A sorted vector of the indices of all the CUs that hold an object
177 of this name. */
178 std::vector<offset_type> cu_indices;
179
180 /* Minimize CU_INDICES, sorting them and removing duplicates as
181 appropriate. */
182 void minimize ();
183};
184
185/* The symbol table. This is a power-of-2-sized hash table. */
187{
189 {
190 data.resize (1024);
191 }
192
193 /* Minimize each entry in the symbol table, removing duplicates. */
194 void minimize ()
195 {
196 for (symtab_index_entry &item : data)
197 item.minimize ();
198 }
199
201 std::vector<symtab_index_entry> data;
202
203 /* Temporary storage for names. */
204 auto_obstack m_string_obstack;
205};
206
207/* Find a slot in SYMTAB for the symbol NAME. Returns a reference to
208 the slot.
209
210 Function is used only during write_hash_table so no index format backward
211 compatibility is needed. */
212
213static symtab_index_entry &
214find_slot (struct mapped_symtab *symtab, const char *name)
215{
216 offset_type index, step, hash = mapped_index_string_hash (INT_MAX, name);
217
218 index = hash & (symtab->data.size () - 1);
219 step = ((hash * 17) & (symtab->data.size () - 1)) | 1;
220
221 for (;;)
222 {
223 if (symtab->data[index].name == NULL
224 || strcmp (name, symtab->data[index].name) == 0)
225 return symtab->data[index];
226 index = (index + step) & (symtab->data.size () - 1);
227 }
228}
229
230/* Expand SYMTAB's hash table. */
231
232static void
234{
235 auto old_entries = std::move (symtab->data);
236
237 symtab->data.clear ();
238 symtab->data.resize (old_entries.size () * 2);
239
240 for (auto &it : old_entries)
241 if (it.name != NULL)
242 {
243 auto &ref = find_slot (symtab, it.name);
244 ref = std::move (it);
245 }
246}
247
248/* Add an entry to SYMTAB. NAME is the name of the symbol.
249 CU_INDEX is the index of the CU in which the symbol appears.
250 IS_STATIC is one if the symbol is static, otherwise zero (global). */
251
252static void
254 int is_static, gdb_index_symbol_kind kind,
255 offset_type cu_index)
256{
257 offset_type cu_index_and_attrs;
258
259 ++symtab->n_elements;
260 if (4 * symtab->n_elements / 3 >= symtab->data.size ())
262
264 if (slot.name == NULL)
265 {
266 slot.name = name;
267 /* index_offset is set later. */
268 }
269
270 cu_index_and_attrs = 0;
271 DW2_GDB_INDEX_CU_SET_VALUE (cu_index_and_attrs, cu_index);
272 DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE (cu_index_and_attrs, is_static);
273 DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE (cu_index_and_attrs, kind);
274
275 /* We don't want to record an index value twice as we want to avoid the
276 duplication.
277 We process all global symbols and then all static symbols
278 (which would allow us to avoid the duplication by only having to check
279 the last entry pushed), but a symbol could have multiple kinds in one CU.
280 To keep things simple we don't worry about the duplication here and
281 sort and uniquify the list after we've processed all symbols. */
282 slot.cu_indices.push_back (cu_index_and_attrs);
283}
284
285/* See symtab_index_entry. */
286
287void
289{
290 if (name == nullptr || cu_indices.empty ())
291 return;
292
293 std::sort (cu_indices.begin (), cu_indices.end ());
294 auto from = std::unique (cu_indices.begin (), cu_indices.end ());
295 cu_indices.erase (from, cu_indices.end ());
296
297 /* We don't want to enter a variable or type more than once, so
298 remove any such duplicates from the list as well. When doing
299 this, we want to keep the entry from the first CU -- but this is
300 implicit due to the sort. This choice is done because it's
301 similar to what gdb historically did for partial symbols. */
302 std::unordered_set<offset_type> seen;
303 from = std::remove_if (cu_indices.begin (), cu_indices.end (),
304 [&] (offset_type val)
305 {
306 gdb_index_symbol_kind kind = GDB_INDEX_SYMBOL_KIND_VALUE (val);
307 if (kind != GDB_INDEX_SYMBOL_KIND_TYPE
308 && kind != GDB_INDEX_SYMBOL_KIND_VARIABLE)
309 return false;
310
311 val &= ~GDB_INDEX_CU_MASK;
312 return !seen.insert (val).second;
313 });
314 cu_indices.erase (from, cu_indices.end ());
315}
316
317/* A form of 'const char *' suitable for container keys. Only the
318 pointer is stored. The strings themselves are compared, not the
319 pointers. */
321{
322public:
323 c_str_view (const char *cstr)
324 : m_cstr (cstr)
325 {}
326
327 bool operator== (const c_str_view &other) const
328 {
329 return strcmp (m_cstr, other.m_cstr) == 0;
330 }
331
332 /* Return the underlying C string. Note, the returned string is
333 only a reference with lifetime of this object. */
334 const char *c_str () const
335 {
336 return m_cstr;
337 }
338
339private:
340 friend class c_str_view_hasher;
341 const char *const m_cstr;
342};
343
344/* A std::unordered_map::hasher for c_str_view that uses the right
345 hash function for strings in a mapped index. */
347{
348public:
349 size_t operator () (const c_str_view &x) const
350 {
352 }
353};
354
355/* A std::unordered_map::hasher for std::vector<>. */
356template<typename T>
358{
359public:
360 size_t operator () (const std::vector<T> &key) const
361 {
362 return iterative_hash (key.data (),
363 sizeof (key.front ()) * key.size (), 0);
364 }
365};
366
367/* Write the mapped hash table SYMTAB to the data buffer OUTPUT, with
368 constant pool entries going into the data buffer CPOOL. */
369
370static void
372{
373 {
374 /* Elements are sorted vectors of the indices of all the CUs that
375 hold an object of this name. */
376 std::unordered_map<std::vector<offset_type>, offset_type,
378 symbol_hash_table;
379
380 /* We add all the index vectors to the constant pool first, to
381 ensure alignment is ok. */
382 for (symtab_index_entry &entry : symtab->data)
383 {
384 if (entry.name == NULL)
385 continue;
386 gdb_assert (entry.index_offset == 0);
387
388 /* Finding before inserting is faster than always trying to
389 insert, because inserting always allocates a node, does the
390 lookup, and then destroys the new node if another node
391 already had the same key. C++17 try_emplace will avoid
392 this. */
393 const auto found
394 = symbol_hash_table.find (entry.cu_indices);
395 if (found != symbol_hash_table.end ())
396 {
397 entry.index_offset = found->second;
398 continue;
399 }
400
401 symbol_hash_table.emplace (entry.cu_indices, cpool.size ());
402 entry.index_offset = cpool.size ();
403 cpool.append_offset (entry.cu_indices.size ());
404 for (const auto index : entry.cu_indices)
405 cpool.append_offset (index);
406 }
407 }
408
409 /* Now write out the hash table. */
410 std::unordered_map<c_str_view, offset_type, c_str_view_hasher> str_table;
411 for (const auto &entry : symtab->data)
412 {
413 offset_type str_off, vec_off;
414
415 if (entry.name != NULL)
416 {
417 const auto insertpair = str_table.emplace (entry.name, cpool.size ());
418 if (insertpair.second)
419 cpool.append_cstr0 (entry.name);
420 str_off = insertpair.first->second;
421 vec_off = entry.index_offset;
422 }
423 else
424 {
425 /* While 0 is a valid constant pool index, it is not valid
426 to have 0 for both offsets. */
427 str_off = 0;
428 vec_off = 0;
429 }
430
431 output.append_offset (str_off);
432 output.append_offset (vec_off);
433 }
434}
435
436typedef std::unordered_map<dwarf2_per_cu_data *, unsigned int> cu_index_map;
437
438/* Helper struct for building the address table. */
440{
441 addrmap_index_data (data_buf &addr_vec_, cu_index_map &cu_index_htab_)
442 : addr_vec (addr_vec_),
443 cu_index_htab (cu_index_htab_)
444 {}
445
448
449 int operator() (CORE_ADDR start_addr, void *obj);
450
451 /* True if the previous_* fields are valid.
452 We can't write an entry until we see the next entry (since it is only then
453 that we know the end of the entry). */
454 bool previous_valid = false;
455 /* Index of the CU in the table of all CUs in the index file. */
456 unsigned int previous_cu_index = 0;
457 /* Start address of the CU. */
458 CORE_ADDR previous_cu_start = 0;
459};
460
461/* Write an address entry to ADDR_VEC. */
462
463static void
465 CORE_ADDR start, CORE_ADDR end, unsigned int cu_index)
466{
467 addr_vec.append_uint (8, BFD_ENDIAN_LITTLE, start);
468 addr_vec.append_uint (8, BFD_ENDIAN_LITTLE, end);
469 addr_vec.append_offset (cu_index);
470}
471
472/* Worker function for traversing an addrmap to build the address table. */
473
474int
475addrmap_index_data::operator() (CORE_ADDR start_addr, void *obj)
476{
477 dwarf2_per_cu_data *per_cu = (dwarf2_per_cu_data *) obj;
478
479 if (previous_valid)
481 previous_cu_start, start_addr,
483
484 previous_cu_start = start_addr;
485 if (per_cu != NULL)
486 {
487 const auto it = cu_index_htab.find (per_cu);
488 gdb_assert (it != cu_index_htab.cend ());
489 previous_cu_index = it->second;
490 previous_valid = true;
491 }
492 else
493 previous_valid = false;
494
495 return 0;
496}
497
498/* Write PER_BFD's address map to ADDR_VEC.
499 CU_INDEX_HTAB is used to map addrmap entries to their CU indices
500 in the index file. */
501
502static void
504 cu_index_map &cu_index_htab)
505{
507
509
510 /* It's highly unlikely the last entry (end address = 0xff...ff)
511 is valid, but we should still handle it.
512 The end address is recorded as the start of the next region, but that
513 doesn't work here. To cope we pass 0xff...ff, this is a rare situation
514 anyway. */
519}
520
521/* DWARF-5 .debug_names builder. */
523{
524public:
525 debug_names (dwarf2_per_objfile *per_objfile, bool is_dwarf64,
526 bfd_endian dwarf5_byte_order)
527 : m_dwarf5_byte_order (dwarf5_byte_order),
528 m_dwarf32 (dwarf5_byte_order),
529 m_dwarf64 (dwarf5_byte_order),
530 m_dwarf (is_dwarf64
531 ? static_cast<dwarf &> (m_dwarf64)
532 : static_cast<dwarf &> (m_dwarf32)),
533 m_name_table_string_offs (m_dwarf.name_table_string_offs),
534 m_name_table_entry_offs (m_dwarf.name_table_entry_offs),
535 m_debugstrlookup (per_objfile)
536 {}
537
539 {
540 const bool dwarf5_is_dwarf64 = &m_dwarf == &m_dwarf64;
541 return dwarf5_is_dwarf64 ? 8 : 4;
542 }
543
544 /* Is this symbol from DW_TAG_compile_unit or DW_TAG_type_unit? */
545 enum class unit_kind { cu, tu };
546
547 /* Insert one symbol. */
548 void insert (const cooked_index_entry *entry)
549 {
550 const auto it = m_cu_index_htab.find (entry->per_cu);
551 gdb_assert (it != m_cu_index_htab.cend ());
552 const char *name = entry->full_name (&m_string_obstack);
553
554 /* This is incorrect but it mirrors gdb's historical behavior; and
555 because the current .debug_names generation is also incorrect,
556 it seems better to follow what was done before, rather than
557 introduce a mismatch between the newer and older gdb. */
558 dwarf_tag tag = entry->tag;
559 if (tag != DW_TAG_typedef && tag_is_type (tag))
560 tag = DW_TAG_structure_type;
561 else if (tag == DW_TAG_enumerator || tag == DW_TAG_constant)
562 tag = DW_TAG_variable;
563
564 int cu_index = it->second;
565 bool is_static = (entry->flags & IS_STATIC) != 0;
566 unit_kind kind = (entry->per_cu->is_debug_types
568 : unit_kind::cu);
569
570 if (entry->per_cu->lang () == language_ada)
571 {
572 /* We want to ensure that the Ada main function's name appears
573 verbatim in the index. However, this name will be of the
574 form "_ada_mumble", and will be rewritten by ada_decode.
575 So, recognize it specially here and add it to the index by
576 hand. */
577 if (strcmp (main_name (), name) == 0)
578 {
579 const auto insertpair
581 std::set<symbol_value> ());
582 std::set<symbol_value> &value_set = insertpair.first->second;
583 value_set.emplace (symbol_value (tag, cu_index, is_static, kind));
584 }
585
586 /* In order for the index to work when read back into gdb, it
587 has to supply a funny form of the name: it should be the
588 encoded name, with any suffixes stripped. Using the
589 ordinary encoded name will not work properly with the
590 searching logic in find_name_components_bounds; nor will
591 using the decoded name. Furthermore, an Ada "verbatim"
592 name (of the form "<MumBle>") must be entered without the
593 angle brackets. Note that the current index is unusual,
594 see PR symtab/24820 for details. */
595 std::string decoded = ada_decode (name);
596 if (decoded[0] == '<')
597 name = (char *) obstack_copy0 (&m_string_obstack,
598 decoded.c_str () + 1,
599 decoded.length () - 2);
600 else
601 name = obstack_strdup (&m_string_obstack,
602 ada_encode (decoded.c_str ()));
603 }
604
605 const auto insertpair
607 std::set<symbol_value> ());
608 std::set<symbol_value> &value_set = insertpair.first->second;
609 value_set.emplace (symbol_value (tag, cu_index, is_static, kind));
610 }
611
612 /* Build all the tables. All symbols must be already inserted.
613 This function does not call file_write, caller has to do it
614 afterwards. */
615 void build ()
616 {
617 /* Verify the build method has not be called twice. */
618 gdb_assert (m_abbrev_table.empty ());
619 const size_t name_count = m_name_to_value_set.size ();
620 m_bucket_table.resize
621 (std::pow (2, std::ceil (std::log2 (name_count * 4 / 3))));
622 m_hash_table.reserve (name_count);
625
626 /* Map each hash of symbol to its name and value. */
627 struct hash_it_pair
628 {
629 uint32_t hash;
630 decltype (m_name_to_value_set)::const_iterator it;
631 };
632 std::vector<std::forward_list<hash_it_pair>> bucket_hash;
633 bucket_hash.resize (m_bucket_table.size ());
634 for (decltype (m_name_to_value_set)::const_iterator it
635 = m_name_to_value_set.cbegin ();
636 it != m_name_to_value_set.cend ();
637 ++it)
638 {
639 const char *const name = it->first.c_str ();
640 const uint32_t hash = dwarf5_djb_hash (name);
641 hash_it_pair hashitpair;
642 hashitpair.hash = hash;
643 hashitpair.it = it;
644 auto &slot = bucket_hash[hash % bucket_hash.size()];
645 slot.push_front (std::move (hashitpair));
646 }
647 for (size_t bucket_ix = 0; bucket_ix < bucket_hash.size (); ++bucket_ix)
648 {
649 const std::forward_list<hash_it_pair> &hashitlist
650 = bucket_hash[bucket_ix];
651 if (hashitlist.empty ())
652 continue;
653 uint32_t &bucket_slot = m_bucket_table[bucket_ix];
654 /* The hashes array is indexed starting at 1. */
655 store_unsigned_integer (reinterpret_cast<gdb_byte *> (&bucket_slot),
656 sizeof (bucket_slot), m_dwarf5_byte_order,
657 m_hash_table.size () + 1);
658 for (const hash_it_pair &hashitpair : hashitlist)
659 {
660 m_hash_table.push_back (0);
661 store_unsigned_integer (reinterpret_cast<gdb_byte *>
662 (&m_hash_table.back ()),
663 sizeof (m_hash_table.back ()),
664 m_dwarf5_byte_order, hashitpair.hash);
665 const c_str_view &name = hashitpair.it->first;
666 const std::set<symbol_value> &value_set = hashitpair.it->second;
668 (m_debugstrlookup.lookup (name.c_str ()));
670 gdb_assert (!value_set.empty ());
671 for (const symbol_value &value : value_set)
672 {
673 int &idx = m_indexkey_to_idx[index_key (value.dwarf_tag,
674 value.is_static,
675 value.kind)];
676 if (idx == 0)
677 {
678 idx = m_idx_next++;
682 (value.kind == unit_kind::cu ? DW_IDX_compile_unit
683 : DW_IDX_type_unit);
686 ? DW_IDX_GNU_internal
687 : DW_IDX_GNU_external);
688 m_abbrev_table.append_unsigned_leb128 (DW_FORM_flag_present);
689
690 /* Terminate attributes list. */
693 }
694
697 }
698
699 /* Terminate the list of CUs. */
701 }
702 }
703 gdb_assert (m_hash_table.size () == name_count);
704
705 /* Terminate tags list. */
707 }
708
709 /* Return .debug_names bucket count. This must be called only after
710 calling the build method. */
711 uint32_t bucket_count () const
712 {
713 /* Verify the build method has been already called. */
714 gdb_assert (!m_abbrev_table.empty ());
715 const uint32_t retval = m_bucket_table.size ();
716
717 /* Check for overflow. */
718 gdb_assert (retval == m_bucket_table.size ());
719 return retval;
720 }
721
722 /* Return .debug_names names count. This must be called only after
723 calling the build method. */
724 uint32_t name_count () const
725 {
726 /* Verify the build method has been already called. */
727 gdb_assert (!m_abbrev_table.empty ());
728 const uint32_t retval = m_hash_table.size ();
729
730 /* Check for overflow. */
731 gdb_assert (retval == m_hash_table.size ());
732 return retval;
733 }
734
735 /* Return number of bytes of .debug_names abbreviation table. This
736 must be called only after calling the build method. */
737 uint32_t abbrev_table_bytes () const
738 {
739 gdb_assert (!m_abbrev_table.empty ());
740 return m_abbrev_table.size ();
741 }
742
743 /* Return number of bytes the .debug_names section will have. This
744 must be called only after calling the build method. */
745 size_t bytes () const
746 {
747 /* Verify the build method has been already called. */
748 gdb_assert (!m_abbrev_table.empty ());
749 size_t expected_bytes = 0;
750 expected_bytes += m_bucket_table.size () * sizeof (m_bucket_table[0]);
751 expected_bytes += m_hash_table.size () * sizeof (m_hash_table[0]);
752 expected_bytes += m_name_table_string_offs.bytes ();
753 expected_bytes += m_name_table_entry_offs.bytes ();
754 expected_bytes += m_abbrev_table.size ();
755 expected_bytes += m_entry_pool.size ();
756 return expected_bytes;
757 }
758
759 /* Write .debug_names to FILE_NAMES and .debug_str addition to
760 FILE_STR. This must be called only after calling the build
761 method. */
762 void file_write (FILE *file_names, FILE *file_str) const
763 {
764 /* Verify the build method has been already called. */
765 gdb_assert (!m_abbrev_table.empty ());
766 ::file_write (file_names, m_bucket_table);
767 ::file_write (file_names, m_hash_table);
770 m_abbrev_table.file_write (file_names);
771 m_entry_pool.file_write (file_names);
772 m_debugstrlookup.file_write (file_str);
773 }
774
776 {
777 m_cu_index_htab.emplace (per_cu, index);
778 }
779
780private:
781
782 /* Storage for symbol names mapping them to their .debug_str section
783 offsets. */
785 {
786 public:
787
788 /* Object constructor to be called for current DWARF2_PER_OBJFILE.
789 All .debug_str section strings are automatically stored. */
791 : m_abfd (per_objfile->objfile->obfd.get ()),
792 m_per_objfile (per_objfile)
793 {
794 per_objfile->per_bfd->str.read (per_objfile->objfile);
795 if (per_objfile->per_bfd->str.buffer == NULL)
796 return;
797 for (const gdb_byte *data = per_objfile->per_bfd->str.buffer;
798 data < (per_objfile->per_bfd->str.buffer
799 + per_objfile->per_bfd->str.size);)
800 {
801 const char *const s = reinterpret_cast<const char *> (data);
802 const auto insertpair
803 = m_str_table.emplace (c_str_view (s),
804 data - per_objfile->per_bfd->str.buffer);
805 if (!insertpair.second)
806 complaint (_("Duplicate string \"%s\" in "
807 ".debug_str section [in module %s]"),
808 s, bfd_get_filename (m_abfd));
809 data += strlen (s) + 1;
810 }
811 }
812
813 /* Return offset of symbol name S in the .debug_str section. Add
814 such symbol to the section's end if it does not exist there
815 yet. */
816 size_t lookup (const char *s)
817 {
818 const auto it = m_str_table.find (c_str_view (s));
819 if (it != m_str_table.end ())
820 return it->second;
821 const size_t offset = (m_per_objfile->per_bfd->str.size
822 + m_str_add_buf.size ());
823 m_str_table.emplace (c_str_view (s), offset);
825 return offset;
826 }
827
828 /* Append the end of the .debug_str section to FILE. */
829 void file_write (FILE *file) const
830 {
832 }
833
834 private:
835 std::unordered_map<c_str_view, size_t, c_str_view_hasher> m_str_table;
836 bfd *const m_abfd;
838
839 /* Data to add at the end of .debug_str for new needed symbol names. */
841 };
842
843 /* Container to map used DWARF tags to their .debug_names abbreviation
844 tags. */
846 {
847 public:
848 index_key (int dwarf_tag_, bool is_static_, unit_kind kind_)
849 : dwarf_tag (dwarf_tag_), is_static (is_static_), kind (kind_)
850 {
851 }
852
853 bool
854 operator== (const index_key &other) const
855 {
856 return (dwarf_tag == other.dwarf_tag && is_static == other.is_static
857 && kind == other.kind);
858 }
859
860 const int dwarf_tag;
861 const bool is_static;
863 };
864
865 /* Provide std::unordered_map::hasher for index_key. */
867 {
868 public:
869 size_t
870 operator () (const index_key &key) const
871 {
872 return (std::hash<int>() (key.dwarf_tag) << 1) | key.is_static;
873 }
874 };
875
876 /* Parameters of one symbol entry. */
878 {
879 public:
880 const int dwarf_tag, cu_index;
881 const bool is_static;
883
884 symbol_value (int dwarf_tag_, int cu_index_, bool is_static_,
885 unit_kind kind_)
886 : dwarf_tag (dwarf_tag_), cu_index (cu_index_), is_static (is_static_),
887 kind (kind_)
888 {}
889
890 bool
891 operator< (const symbol_value &other) const
892 {
893#define X(n) \
894 do \
895 { \
896 if (n < other.n) \
897 return true; \
898 if (n > other.n) \
899 return false; \
900 } \
901 while (0)
902 X (dwarf_tag);
903 X (is_static);
904 X (kind);
905 X (cu_index);
906#undef X
907 return false;
908 }
909 };
910
911 /* Abstract base class to unify DWARF-32 and DWARF-64 name table
912 output. */
914 {
915 protected:
916 const bfd_endian dwarf5_byte_order;
917 public:
918 explicit offset_vec (bfd_endian dwarf5_byte_order_)
919 : dwarf5_byte_order (dwarf5_byte_order_)
920 {}
921
922 /* Call std::vector::reserve for NELEM elements. */
923 virtual void reserve (size_t nelem) = 0;
924
925 /* Call std::vector::push_back with store_unsigned_integer byte
926 reordering for ELEM. */
927 virtual void push_back_reorder (size_t elem) = 0;
928
929 /* Return expected output size in bytes. */
930 virtual size_t bytes () const = 0;
931
932 /* Write name table to FILE. */
933 virtual void file_write (FILE *file) const = 0;
934 };
935
936 /* Template to unify DWARF-32 and DWARF-64 output. */
937 template<typename OffsetSize>
939 {
940 public:
941 explicit offset_vec_tmpl (bfd_endian dwarf5_byte_order_)
942 : offset_vec (dwarf5_byte_order_)
943 {}
944
945 /* Implement offset_vec::reserve. */
946 void reserve (size_t nelem) override
947 {
948 m_vec.reserve (nelem);
949 }
950
951 /* Implement offset_vec::push_back_reorder. */
952 void push_back_reorder (size_t elem) override
953 {
954 m_vec.push_back (elem);
955 /* Check for overflow. */
956 gdb_assert (m_vec.back () == elem);
957 store_unsigned_integer (reinterpret_cast<gdb_byte *> (&m_vec.back ()),
958 sizeof (m_vec.back ()), dwarf5_byte_order, elem);
959 }
960
961 /* Implement offset_vec::bytes. */
962 size_t bytes () const override
963 {
964 return m_vec.size () * sizeof (m_vec[0]);
965 }
966
967 /* Implement offset_vec::file_write. */
968 void file_write (FILE *file) const override
969 {
970 ::file_write (file, m_vec);
971 }
972
973 private:
974 std::vector<OffsetSize> m_vec;
975 };
976
977 /* Base class to unify DWARF-32 and DWARF-64 .debug_names output
978 respecting name table width. */
979 class dwarf
980 {
981 public:
983
984 dwarf (offset_vec &name_table_string_offs_,
985 offset_vec &name_table_entry_offs_)
986 : name_table_string_offs (name_table_string_offs_),
987 name_table_entry_offs (name_table_entry_offs_)
988 {
989 }
990 };
991
992 /* Template to unify DWARF-32 and DWARF-64 .debug_names output
993 respecting name table width. */
994 template<typename OffsetSize>
995 class dwarf_tmpl : public dwarf
996 {
997 public:
998 explicit dwarf_tmpl (bfd_endian dwarf5_byte_order_)
1000 m_name_table_string_offs (dwarf5_byte_order_),
1001 m_name_table_entry_offs (dwarf5_byte_order_)
1002 {}
1003
1004 private:
1007 };
1008
1009 /* Store value of each symbol. */
1010 std::unordered_map<c_str_view, std::set<symbol_value>, c_str_view_hasher>
1012
1013 /* Tables of DWARF-5 .debug_names. They are in object file byte
1014 order. */
1015 std::vector<uint32_t> m_bucket_table;
1016 std::vector<uint32_t> m_hash_table;
1017
1018 const bfd_endian m_dwarf5_byte_order;
1024
1025 /* Map each used .debug_names abbreviation tag parameter to its
1026 index value. */
1027 std::unordered_map<index_key, int, index_key_hasher> m_indexkey_to_idx;
1028
1029 /* Next unused .debug_names abbreviation tag for
1030 m_indexkey_to_idx. */
1031 int m_idx_next = 1;
1032
1033 /* .debug_names abbreviation table. */
1035
1036 /* .debug_names entry pool. */
1038
1039 /* Temporary storage for Ada names. */
1040 auto_obstack m_string_obstack;
1041
1043};
1044
1045/* Return iff any of the needed offsets does not fit into 32-bit
1046 .debug_names section. */
1047
1048static bool
1050{
1051 for (const auto &per_cu : per_objfile->per_bfd->all_units)
1052 {
1053 if (to_underlying (per_cu->sect_off)
1054 >= (static_cast<uint64_t> (1) << 32))
1055 return true;
1056 }
1057 return false;
1058}
1059
1060/* Assert that FILE's size is EXPECTED_SIZE. Assumes file's seek
1061 position is at the end of the file. */
1062
1063static void
1064assert_file_size (FILE *file, size_t expected_size)
1065{
1066 const auto file_size = ftell (file);
1067 if (file_size == -1)
1068 perror_with_name (("ftell"));
1069 gdb_assert (file_size == expected_size);
1070}
1071
1072/* Write a gdb index file to OUT_FILE from all the sections passed as
1073 arguments. */
1074
1075static void
1076write_gdbindex_1 (FILE *out_file,
1077 const data_buf &cu_list,
1078 const data_buf &types_cu_list,
1079 const data_buf &addr_vec,
1080 const data_buf &symtab_vec,
1081 const data_buf &constant_pool)
1082{
1083 data_buf contents;
1084 const offset_type size_of_header = 6 * sizeof (offset_type);
1085 offset_type total_len = size_of_header;
1086
1087 /* The version number. */
1088 contents.append_offset (8);
1089
1090 /* The offset of the CU list from the start of the file. */
1091 contents.append_offset (total_len);
1092 total_len += cu_list.size ();
1093
1094 /* The offset of the types CU list from the start of the file. */
1095 contents.append_offset (total_len);
1096 total_len += types_cu_list.size ();
1097
1098 /* The offset of the address table from the start of the file. */
1099 contents.append_offset (total_len);
1100 total_len += addr_vec.size ();
1101
1102 /* The offset of the symbol table from the start of the file. */
1103 contents.append_offset (total_len);
1104 total_len += symtab_vec.size ();
1105
1106 /* The offset of the constant pool from the start of the file. */
1107 contents.append_offset (total_len);
1108 total_len += constant_pool.size ();
1109
1110 gdb_assert (contents.size () == size_of_header);
1111
1112 contents.file_write (out_file);
1113 cu_list.file_write (out_file);
1114 types_cu_list.file_write (out_file);
1115 addr_vec.file_write (out_file);
1116 symtab_vec.file_write (out_file);
1117 constant_pool.file_write (out_file);
1118
1119 assert_file_size (out_file, total_len);
1120}
1121
1122/* Write the contents of the internal "cooked" index. */
1123
1124static void
1126 const cu_index_map &cu_index_htab,
1127 struct mapped_symtab *symtab)
1128{
1129 const char *main_for_ada = main_name ();
1130
1131 for (const cooked_index_entry *entry : table->all_entries ())
1132 {
1133 const auto it = cu_index_htab.find (entry->per_cu);
1134 gdb_assert (it != cu_index_htab.cend ());
1135
1136 const char *name = entry->full_name (&symtab->m_string_obstack);
1137
1138 if (entry->per_cu->lang () == language_ada)
1139 {
1140 /* We want to ensure that the Ada main function's name
1141 appears verbatim in the index. However, this name will
1142 be of the form "_ada_mumble", and will be rewritten by
1143 ada_decode. So, recognize it specially here and add it
1144 to the index by hand. */
1145 if (entry->tag == DW_TAG_subprogram
1146 && strcmp (main_for_ada, name) == 0)
1147 {
1148 /* Leave it alone. */
1149 }
1150 else
1151 {
1152 /* In order for the index to work when read back into
1153 gdb, it has to use the encoded name, with any
1154 suffixes stripped. */
1155 std::string encoded = ada_encode (name, false);
1156 name = obstack_strdup (&symtab->m_string_obstack,
1157 encoded.c_str ());
1158 }
1159 }
1160 else if (entry->per_cu->lang () == language_cplus
1161 && (entry->flags & IS_LINKAGE) != 0)
1162 {
1163 /* GDB never put C++ linkage names into .gdb_index. The
1164 theory here is that a linkage name will normally be in
1165 the minimal symbols anyway, so including it in the index
1166 is usually redundant -- and the cases where it would not
1167 be redundant are rare and not worth supporting. */
1168 continue;
1169 }
1170 else if ((entry->flags & IS_TYPE_DECLARATION) != 0)
1171 {
1172 /* Don't add type declarations to the index. */
1173 continue;
1174 }
1175
1176 gdb_index_symbol_kind kind;
1177 if (entry->tag == DW_TAG_subprogram)
1178 kind = GDB_INDEX_SYMBOL_KIND_FUNCTION;
1179 else if (entry->tag == DW_TAG_variable
1180 || entry->tag == DW_TAG_constant
1181 || entry->tag == DW_TAG_enumerator)
1182 kind = GDB_INDEX_SYMBOL_KIND_VARIABLE;
1183 else if (entry->tag == DW_TAG_module
1184 || entry->tag == DW_TAG_common_block)
1185 kind = GDB_INDEX_SYMBOL_KIND_OTHER;
1186 else
1187 kind = GDB_INDEX_SYMBOL_KIND_TYPE;
1188
1189 add_index_entry (symtab, name, (entry->flags & IS_STATIC) != 0,
1190 kind, it->second);
1191 }
1192}
1193
1194/* Write contents of a .gdb_index section for OBJFILE into OUT_FILE.
1195 If OBJFILE has an associated dwz file, write contents of a .gdb_index
1196 section for that dwz file into DWZ_OUT_FILE. If OBJFILE does not have an
1197 associated dwz file, DWZ_OUT_FILE must be NULL. */
1198
1199static void
1201 cooked_index_vector *table,
1202 FILE *out_file, FILE *dwz_out_file)
1203{
1205 data_buf objfile_cu_list;
1206 data_buf dwz_cu_list;
1207
1208 /* While we're scanning CU's create a table that maps a dwarf2_per_cu_data
1209 (which is what addrmap records) to its index (which is what is recorded
1210 in the index file). This will later be needed to write the address
1211 table. */
1212 cu_index_map cu_index_htab;
1213 cu_index_htab.reserve (per_objfile->per_bfd->all_units.size ());
1214
1215 /* Store out the .debug_type CUs, if any. */
1216 data_buf types_cu_list;
1217
1218 /* The CU list is already sorted, so we don't need to do additional
1219 work here. Also, the debug_types entries do not appear in
1220 all_units, but only in their own hash table. */
1221
1222 int counter = 0;
1223 int types_counter = 0;
1224 for (int i = 0; i < per_objfile->per_bfd->all_units.size (); ++i)
1225 {
1226 dwarf2_per_cu_data *per_cu
1227 = per_objfile->per_bfd->all_units[i].get ();
1228
1229 int &this_counter = per_cu->is_debug_types ? types_counter : counter;
1230
1231 const auto insertpair = cu_index_htab.emplace (per_cu, this_counter);
1232 gdb_assert (insertpair.second);
1233
1234 /* The all_units list contains CUs read from the objfile as well as
1235 from the eventual dwz file. We need to place the entry in the
1236 corresponding index. */
1237 data_buf &cu_list = (per_cu->is_debug_types
1238 ? types_cu_list
1239 : per_cu->is_dwz ? dwz_cu_list : objfile_cu_list);
1240 cu_list.append_uint (8, BFD_ENDIAN_LITTLE,
1241 to_underlying (per_cu->sect_off));
1242 if (per_cu->is_debug_types)
1243 {
1244 signatured_type *sig_type = (signatured_type *) per_cu;
1245 cu_list.append_uint (8, BFD_ENDIAN_LITTLE,
1246 to_underlying (sig_type->type_offset_in_tu));
1247 cu_list.append_uint (8, BFD_ENDIAN_LITTLE,
1248 sig_type->signature);
1249 }
1250 else
1251 cu_list.append_uint (8, BFD_ENDIAN_LITTLE, per_cu->length ());
1252
1253 ++this_counter;
1254 }
1255
1256 write_cooked_index (table, cu_index_htab, &symtab);
1257
1258 /* Dump the address map. */
1259 data_buf addr_vec;
1260 for (auto map : table->get_addrmaps ())
1261 write_address_map (map, addr_vec, cu_index_htab);
1262
1263 /* Now that we've processed all symbols we can shrink their cu_indices
1264 lists. */
1265 symtab.minimize ();
1266
1267 data_buf symtab_vec, constant_pool;
1268 if (symtab.n_elements == 0)
1269 symtab.data.resize (0);
1270
1271 write_hash_table (&symtab, symtab_vec, constant_pool);
1272
1273 write_gdbindex_1(out_file, objfile_cu_list, types_cu_list, addr_vec,
1274 symtab_vec, constant_pool);
1275
1276 if (dwz_out_file != NULL)
1277 write_gdbindex_1 (dwz_out_file, dwz_cu_list, {}, {}, {}, {});
1278 else
1279 gdb_assert (dwz_cu_list.empty ());
1280}
1281
1282/* DWARF-5 augmentation string for GDB's DW_IDX_GNU_* extension. */
1283static const gdb_byte dwarf5_gdb_augmentation[] = { 'G', 'D', 'B', 0 };
1284
1285/* Write a new .debug_names section for OBJFILE into OUT_FILE, write
1286 needed addition to .debug_str section to OUT_FILE_STR. Return how
1287 many bytes were expected to be written into OUT_FILE. */
1288
1289static void
1291 cooked_index_vector *table,
1292 FILE *out_file, FILE *out_file_str)
1293{
1294 const bool dwarf5_is_dwarf64 = check_dwarf64_offsets (per_objfile);
1295 struct objfile *objfile = per_objfile->objfile;
1296 const enum bfd_endian dwarf5_byte_order
1298
1299 /* The CU list is already sorted, so we don't need to do additional
1300 work here. Also, the debug_types entries do not appear in
1301 all_units, but only in their own hash table. */
1302 data_buf cu_list;
1303 data_buf types_cu_list;
1304 debug_names nametable (per_objfile, dwarf5_is_dwarf64, dwarf5_byte_order);
1305 int counter = 0;
1306 int types_counter = 0;
1307 for (int i = 0; i < per_objfile->per_bfd->all_units.size (); ++i)
1308 {
1309 dwarf2_per_cu_data *per_cu
1310 = per_objfile->per_bfd->all_units[i].get ();
1311
1312 int &this_counter = per_cu->is_debug_types ? types_counter : counter;
1313 data_buf &this_list = per_cu->is_debug_types ? types_cu_list : cu_list;
1314
1315 nametable.add_cu (per_cu, this_counter);
1316 this_list.append_uint (nametable.dwarf5_offset_size (),
1317 dwarf5_byte_order,
1318 to_underlying (per_cu->sect_off));
1319 ++this_counter;
1320 }
1321
1322 /* Verify that all units are represented. */
1323 gdb_assert (counter == per_objfile->per_bfd->all_comp_units.size ());
1324 gdb_assert (types_counter == per_objfile->per_bfd->all_type_units.size ());
1325
1326 for (const cooked_index_entry *entry : table->all_entries ())
1327 nametable.insert (entry);
1328
1329 nametable.build ();
1330
1331 /* No addr_vec - DWARF-5 uses .debug_aranges generated by GCC. */
1332
1333 const offset_type bytes_of_header
1334 = ((dwarf5_is_dwarf64 ? 12 : 4)
1335 + 2 + 2 + 7 * 4
1336 + sizeof (dwarf5_gdb_augmentation));
1337 size_t expected_bytes = 0;
1338 expected_bytes += bytes_of_header;
1339 expected_bytes += cu_list.size ();
1340 expected_bytes += types_cu_list.size ();
1341 expected_bytes += nametable.bytes ();
1342 data_buf header;
1343
1344 if (!dwarf5_is_dwarf64)
1345 {
1346 const uint64_t size64 = expected_bytes - 4;
1347 gdb_assert (size64 < 0xfffffff0);
1348 header.append_uint (4, dwarf5_byte_order, size64);
1349 }
1350 else
1351 {
1352 header.append_uint (4, dwarf5_byte_order, 0xffffffff);
1353 header.append_uint (8, dwarf5_byte_order, expected_bytes - 12);
1354 }
1355
1356 /* The version number. */
1357 header.append_uint (2, dwarf5_byte_order, 5);
1358
1359 /* Padding. */
1360 header.append_uint (2, dwarf5_byte_order, 0);
1361
1362 /* comp_unit_count - The number of CUs in the CU list. */
1363 header.append_uint (4, dwarf5_byte_order, counter);
1364
1365 /* local_type_unit_count - The number of TUs in the local TU
1366 list. */
1367 header.append_uint (4, dwarf5_byte_order, types_counter);
1368
1369 /* foreign_type_unit_count - The number of TUs in the foreign TU
1370 list. */
1371 header.append_uint (4, dwarf5_byte_order, 0);
1372
1373 /* bucket_count - The number of hash buckets in the hash lookup
1374 table. */
1375 header.append_uint (4, dwarf5_byte_order, nametable.bucket_count ());
1376
1377 /* name_count - The number of unique names in the index. */
1378 header.append_uint (4, dwarf5_byte_order, nametable.name_count ());
1379
1380 /* abbrev_table_size - The size in bytes of the abbreviations
1381 table. */
1382 header.append_uint (4, dwarf5_byte_order, nametable.abbrev_table_bytes ());
1383
1384 /* augmentation_string_size - The size in bytes of the augmentation
1385 string. This value is rounded up to a multiple of 4. */
1386 static_assert (sizeof (dwarf5_gdb_augmentation) % 4 == 0, "");
1387 header.append_uint (4, dwarf5_byte_order, sizeof (dwarf5_gdb_augmentation));
1389
1390 gdb_assert (header.size () == bytes_of_header);
1391
1392 header.file_write (out_file);
1393 cu_list.file_write (out_file);
1394 types_cu_list.file_write (out_file);
1395 nametable.file_write (out_file, out_file_str);
1396
1397 assert_file_size (out_file, expected_bytes);
1398}
1399
1400/* This represents an index file being written (work-in-progress).
1401
1402 The data is initially written to a temporary file. When the finalize method
1403 is called, the file is closed and moved to its final location.
1404
1405 On failure (if this object is being destroyed with having called finalize),
1406 the temporary file is closed and deleted. */
1407
1409{
1410 index_wip_file (const char *dir, const char *basename,
1411 const char *suffix)
1412 {
1413 filename = (std::string (dir) + SLASH_STRING + basename
1414 + suffix);
1415
1416 filename_temp = make_temp_filename (filename);
1417
1418 scoped_fd out_file_fd = gdb_mkostemp_cloexec (filename_temp.data (),
1419 O_BINARY);
1420 if (out_file_fd.get () == -1)
1421 perror_with_name (("mkstemp"));
1422
1423 out_file = out_file_fd.to_file ("wb");
1424
1425 if (out_file == nullptr)
1426 error (_("Can't open `%s' for writing"), filename_temp.data ());
1427
1428 unlink_file.emplace (filename_temp.data ());
1429 }
1430
1431 void finalize ()
1432 {
1433 /* We want to keep the file. */
1434 unlink_file->keep ();
1435
1436 /* Close and move the str file in place. */
1437 unlink_file.reset ();
1438 if (rename (filename_temp.data (), filename.c_str ()) != 0)
1439 perror_with_name (("rename"));
1440 }
1441
1442 std::string filename;
1443 gdb::char_vector filename_temp;
1444
1445 /* Order matters here; we want FILE to be closed before
1446 FILENAME_TEMP is unlinked, because on MS-Windows one cannot
1447 delete a file that is still open. So, we wrap the unlinker in an
1448 optional and emplace it once we know the file name. */
1449 gdb::optional<gdb::unlinker> unlink_file;
1450
1451 gdb_file_up out_file;
1452};
1453
1454/* See dwarf-index-write.h. */
1455
1456void
1457write_dwarf_index (dwarf2_per_objfile *per_objfile, const char *dir,
1458 const char *basename, const char *dwz_basename,
1459 dw_index_kind index_kind)
1460{
1461 struct objfile *objfile = per_objfile->objfile;
1462
1463 if (per_objfile->per_bfd->index_table == nullptr)
1464 error (_("No debugging symbols"));
1465 cooked_index_vector *table
1466 = per_objfile->per_bfd->index_table->index_for_writing ();
1467
1468 if (per_objfile->per_bfd->types.size () > 1)
1469 error (_("Cannot make an index when the file has multiple .debug_types sections"));
1470
1471
1472 gdb_assert ((objfile->flags & OBJF_NOT_FILENAME) == 0);
1473
1474 const char *index_suffix = (index_kind == dw_index_kind::DEBUG_NAMES
1476
1477 index_wip_file objfile_index_wip (dir, basename, index_suffix);
1478 gdb::optional<index_wip_file> dwz_index_wip;
1479
1480 if (dwz_basename != NULL)
1481 dwz_index_wip.emplace (dir, dwz_basename, index_suffix);
1482
1483 if (index_kind == dw_index_kind::DEBUG_NAMES)
1484 {
1485 index_wip_file str_wip_file (dir, basename, DEBUG_STR_SUFFIX);
1486
1487 write_debug_names (per_objfile, table, objfile_index_wip.out_file.get (),
1488 str_wip_file.out_file.get ());
1489
1490 str_wip_file.finalize ();
1491 }
1492 else
1493 write_gdbindex (per_objfile, table, objfile_index_wip.out_file.get (),
1494 (dwz_index_wip.has_value ()
1495 ? dwz_index_wip->out_file.get () : NULL));
1496
1497 objfile_index_wip.finalize ();
1498
1499 if (dwz_index_wip.has_value ())
1500 dwz_index_wip->finalize ();
1501}
1502
1503/* Implementation of the `save gdb-index' command.
1504
1505 Note that the .gdb_index file format used by this command is
1506 documented in the GDB manual. Any changes here must be documented
1507 there. */
1508
1509static void
1510save_gdb_index_command (const char *arg, int from_tty)
1511{
1512 const char dwarf5space[] = "-dwarf-5 ";
1514
1515 if (!arg)
1516 arg = "";
1517
1518 arg = skip_spaces (arg);
1519 if (strncmp (arg, dwarf5space, strlen (dwarf5space)) == 0)
1520 {
1521 index_kind = dw_index_kind::DEBUG_NAMES;
1522 arg += strlen (dwarf5space);
1523 arg = skip_spaces (arg);
1524 }
1525
1526 if (!*arg)
1527 error (_("usage: save gdb-index [-dwarf-5] DIRECTORY"));
1528
1530 {
1531 /* If the objfile does not correspond to an actual file, skip it. */
1532 if ((objfile->flags & OBJF_NOT_FILENAME) != 0)
1533 continue;
1534
1536
1537 if (per_objfile != NULL)
1538 {
1539 try
1540 {
1541 const char *basename = lbasename (objfile_name (objfile));
1542 const dwz_file *dwz = dwarf2_get_dwz_file (per_objfile->per_bfd);
1543 const char *dwz_basename = NULL;
1544
1545 if (dwz != NULL)
1546 dwz_basename = lbasename (dwz->filename ());
1547
1548 write_dwarf_index (per_objfile, arg, basename, dwz_basename,
1549 index_kind);
1550 }
1551 catch (const gdb_exception_error &except)
1552 {
1554 _("Error while writing index for `%s': "),
1556 }
1557 }
1558
1559 }
1560}
1561
1563void
1565{
1566 cmd_list_element *c = add_cmd ("gdb-index", class_files,
1568Save a gdb-index file.\n\
1569Usage: save gdb-index [-dwarf-5] DIRECTORY\n\
1570\n\
1571No options create one file with .gdb-index extension for pre-DWARF-5\n\
1572compatible .gdb_index section. With -dwarf-5 creates two files with\n\
1573extension .debug_names and .debug_str for DWARF-5 .debug_names section."),
1574 &save_cmdlist);
1576}
constexpr string_view get()
Definition 70483.cc:49
const char *const name
std::string ada_decode(const char *encoded, bool wrap, bool operators)
Definition ada-lang.c:1310
std::string ada_encode(const char *decoded, bool fold)
Definition ada-lang.c:1154
struct cmd_list_element * save_cmdlist
Definition breakpoint.c:758
size_t operator()(const c_str_view &x) const
const char * c_str() const
bool operator==(const c_str_view &other) const
const char *const m_cstr
c_str_view(const char *cstr)
std::vector< addrmap * > get_addrmaps()
void file_write(FILE *file) const
void append_cstr0(const char *cstr)
void append_array(gdb::array_view< const gdb_byte > array)
Definition index-write.c:98
bool empty() const
void append_uint(size_t len, bfd_endian byte_order, ULONGEST val)
size_t size() const
gdb::byte_vector m_vec
void append_unsigned_leb128(ULONGEST input)
gdb_byte * grow(size_t size)
void append_offset(offset_type value)
debug_str_lookup(dwarf2_per_objfile *per_objfile)
size_t lookup(const char *s)
std::unordered_map< c_str_view, size_t, c_str_view_hasher > m_str_table
dwarf2_per_objfile * m_per_objfile
void file_write(FILE *file) const
dwarf_tmpl(bfd_endian dwarf5_byte_order_)
offset_vec_tmpl< OffsetSize > m_name_table_string_offs
offset_vec_tmpl< OffsetSize > m_name_table_entry_offs
dwarf(offset_vec &name_table_string_offs_, offset_vec &name_table_entry_offs_)
offset_vec & name_table_string_offs
offset_vec & name_table_entry_offs
size_t operator()(const index_key &key) const
index_key(int dwarf_tag_, bool is_static_, unit_kind kind_)
bool operator==(const index_key &other) const
const unit_kind kind
offset_vec_tmpl(bfd_endian dwarf5_byte_order_)
void file_write(FILE *file) const override
void push_back_reorder(size_t elem) override
void reserve(size_t nelem) override
size_t bytes() const override
std::vector< OffsetSize > m_vec
const bfd_endian dwarf5_byte_order
virtual void file_write(FILE *file) const =0
virtual size_t bytes() const =0
virtual void push_back_reorder(size_t elem)=0
virtual void reserve(size_t nelem)=0
offset_vec(bfd_endian dwarf5_byte_order_)
bool operator<(const symbol_value &other) const
symbol_value(int dwarf_tag_, int cu_index_, bool is_static_, unit_kind kind_)
std::vector< uint32_t > m_hash_table
int dwarf5_offset_size() const
void file_write(FILE *file_names, FILE *file_str) const
uint32_t abbrev_table_bytes() const
data_buf m_abbrev_table
uint32_t name_count() const
offset_vec & m_name_table_entry_offs
size_t bytes() const
dwarf_tmpl< uint64_t > m_dwarf64
void add_cu(dwarf2_per_cu_data *per_cu, offset_type index)
dwarf_tmpl< uint32_t > m_dwarf32
data_buf m_entry_pool
std::unordered_map< index_key, int, index_key_hasher > m_indexkey_to_idx
offset_vec & m_name_table_string_offs
void insert(const cooked_index_entry *entry)
cu_index_map m_cu_index_htab
std::unordered_map< c_str_view, std::set< symbol_value >, c_str_view_hasher > m_name_to_value_set
debug_str_lookup m_debugstrlookup
debug_names(dwarf2_per_objfile *per_objfile, bool is_dwarf64, bfd_endian dwarf5_byte_order)
auto_obstack m_string_obstack
dwarf & m_dwarf
std::vector< uint32_t > m_bucket_table
const bfd_endian m_dwarf5_byte_order
uint32_t bucket_count() const
size_t operator()(const std::vector< T > &key) const
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition cli-decode.c:233
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
Definition cli-decode.c:117
@ class_files
Definition command.h:57
#define complaint(FMT,...)
Definition complaints.h:47
void filename_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition completer.c:204
@ IS_TYPE_DECLARATION
@ IS_STATIC
@ IS_LINKAGE
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition defs.h:561
#define O_BINARY
Definition defs.h:116
#define INT_MAX
Definition defs.h:457
@ language_ada
Definition defs.h:226
@ language_cplus
Definition defs.h:216
struct dwz_file * dwarf2_get_dwz_file(dwarf2_per_bfd *per_bfd, bool require)
Definition dwz.c:188
void exception_fprintf(struct ui_file *file, const struct gdb_exception &e, const char *prefix,...)
Definition exceptions.c:115
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition gdbarch.c:1370
bfd * obfd
size_t size
Definition go32-nat.c:241
uint32_t dwarf5_djb_hash(const char *str_)
hashval_t mapped_index_string_hash(int index_version, const void *p)
#define INDEX5_SUFFIX
uint32_t offset_type
#define DEBUG_STR_SUFFIX
#define INDEX4_SUFFIX
static void write_gdbindex_1(FILE *out_file, const data_buf &cu_list, const data_buf &types_cu_list, const data_buf &addr_vec, const data_buf &symtab_vec, const data_buf &constant_pool)
std::unordered_map< dwarf2_per_cu_data *, unsigned int > cu_index_map
#define X(n)
#define DW2_GDB_INDEX_SYMBOL_STATIC_SET_VALUE(cu_index, value)
Definition index-write.c:50
static void write_gdbindex(dwarf2_per_objfile *per_objfile, cooked_index_vector *table, FILE *out_file, FILE *dwz_out_file)
static void assert_file_size(FILE *file, size_t expected_size)
#define DW2_GDB_INDEX_SYMBOL_KIND_SET_VALUE(cu_index, value)
Definition index-write.c:57
static symtab_index_entry & find_slot(struct mapped_symtab *symtab, const char *name)
static void write_cooked_index(cooked_index_vector *table, const cu_index_map &cu_index_htab, struct mapped_symtab *symtab)
#define DW2_GDB_INDEX_CU_SET_VALUE(cu_index, value)
Definition index-write.c:65
static void add_address_entry(data_buf &addr_vec, CORE_ADDR start, CORE_ADDR end, unsigned int cu_index)
static void write_address_map(struct addrmap *addrmap, data_buf &addr_vec, cu_index_map &cu_index_htab)
void _initialize_dwarf_index_write()
static const gdb_byte dwarf5_gdb_augmentation[]
static bool check_dwarf64_offsets(dwarf2_per_objfile *per_objfile)
static void hash_expand(struct mapped_symtab *symtab)
static void file_write(FILE *file, const void *data, size_t size)
Definition index-write.c:77
static void save_gdb_index_command(const char *arg, int from_tty)
void write_dwarf_index(dwarf2_per_objfile *per_objfile, const char *dir, const char *basename, const char *dwz_basename, dw_index_kind index_kind)
static void write_debug_names(dwarf2_per_objfile *per_objfile, cooked_index_vector *table, FILE *out_file, FILE *out_file_str)
static void add_index_entry(struct mapped_symtab *symtab, const char *name, int is_static, gdb_index_symbol_kind kind, offset_type cu_index)
static void write_hash_table(mapped_symtab *symtab, data_buf &output, data_buf &cpool)
@ OBJF_NOT_FILENAME
const char * objfile_name(const struct objfile *objfile)
Definition objfiles.c:1308
struct program_space * current_program_space
Definition progspace.c:39
dw_index_kind
Definition public.h:29
dwarf2_per_objfile * get_dwarf2_per_objfile(struct objfile *objfile)
Definition read.c:311
cu_index_map & cu_index_htab
addrmap_index_data(data_buf &addr_vec_, cu_index_map &cu_index_htab_)
int operator()(CORE_ADDR start_addr, void *obj)
CORE_ADDR previous_cu_start
unsigned int previous_cu_index
data_buf & addr_vec
virtual int foreach(addrmap_foreach_fn fn)=0
dwarf2_per_cu_data * per_cu
enum dwarf_tag tag
const char * full_name(struct obstack *storage, bool for_main=false) const
cooked_index_flag flags
dwarf2_section_info str
Definition read.h:476
gdb::array_view< dwarf2_per_cu_data_up > all_comp_units
Definition read.h:496
std::unique_ptr< dwarf_scanner_base > index_table
Definition read.h:533
gdb::array_view< dwarf2_per_cu_data_up > all_type_units
Definition read.h:497
std::vector< dwarf2_section_info > types
Definition read.h:488
std::vector< dwarf2_per_cu_data_up > all_units
Definition read.h:492
sect_offset sect_off
Definition read.h:120
unsigned int is_dwz
Definition read.h:139
enum language lang(bool strict_p=true) const
Definition read.h:352
unsigned int is_debug_types
Definition read.h:136
unsigned int length() const
Definition read.h:295
struct objfile * objfile
Definition read.h:648
struct dwarf2_per_bfd * per_bfd
Definition read.h:652
void read(struct objfile *objfile)
Definition section.c:119
const gdb_byte * buffer
Definition section.h:115
bfd_size_type size
Definition section.h:117
Definition dwz.h:32
const char * filename() const
Definition dwz.h:38
std::string filename
gdb_file_up out_file
index_wip_file(const char *dir, const char *basename, const char *suffix)
gdb::optional< gdb::unlinker > unlink_file
gdb::char_vector filename_temp
std::vector< symtab_index_entry > data
offset_type n_elements
auto_obstack m_string_obstack
struct gdbarch * arch() const
Definition objfiles.h:482
objfile_flags flags
Definition objfiles.h:637
objfiles_range objfiles()
Definition progspace.h:209
ULONGEST signature
Definition read.h:388
cu_offset type_offset_in_tu
Definition read.h:393
offset_type index_offset
const char * name
std::vector< offset_type > cu_indices
void minimize()
Definition value.c:181
const char * main_name()
Definition symtab.c:6309
static bool tag_is_type(dwarf_tag tag)
Definition tag.h:28
void perror_with_name(const char *string)
Definition utils.c:643
#define gdb_stderr
Definition utils.h:193