Commit | Line | Data |
---|---|---|
77429909 CC |
1 | // dwp.cc -- DWARF packaging utility |
2 | ||
4b95cf5c | 3 | // Copyright (C) 2012-2014 Free Software Foundation, Inc. |
77429909 CC |
4 | // Written by Cary Coutant <ccoutant@google.com>. |
5 | ||
6 | // This file is part of dwp, the DWARF packaging utility. | |
7 | ||
8 | // This program is free software; you can redistribute it and/or modify | |
9 | // it under the terms of the GNU General Public License as published by | |
10 | // the Free Software Foundation; either version 3 of the License, or | |
11 | // (at your option) any later version. | |
12 | ||
13 | // This program is distributed in the hope that it will be useful, | |
14 | // but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | // GNU General Public License for more details. | |
17 | ||
18 | // You should have received a copy of the GNU General Public License | |
19 | // along with this program; if not, write to the Free Software | |
20 | // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, | |
21 | // MA 02110-1301, USA. | |
22 | ||
23 | #include "dwp.h" | |
24 | ||
25 | #include <cstdarg> | |
26 | #include <cstddef> | |
27 | #include <cstdio> | |
28 | #include <cstdlib> | |
29 | #include <cstring> | |
30 | #include <cerrno> | |
31 | ||
32 | #include <vector> | |
33 | #include <algorithm> | |
34 | ||
35 | #include "getopt.h" | |
36 | #include "libiberty.h" | |
c1a8d56e | 37 | #include "../bfd/bfdver.h" |
77429909 CC |
38 | |
39 | #include "elfcpp.h" | |
40 | #include "elfcpp_file.h" | |
908794a9 | 41 | #include "dwarf.h" |
77429909 CC |
42 | #include "dirsearch.h" |
43 | #include "fileread.h" | |
44 | #include "object.h" | |
45 | #include "compressed_output.h" | |
46 | #include "stringpool.h" | |
47 | #include "dwarf_reader.h" | |
48 | ||
49 | static void | |
c1a8d56e CC |
50 | usage(FILE* fd, int) ATTRIBUTE_NORETURN; |
51 | ||
52 | static void | |
53 | print_version() ATTRIBUTE_NORETURN; | |
77429909 CC |
54 | |
55 | namespace gold { | |
56 | ||
57 | class Dwp_output_file; | |
58 | ||
77429909 CC |
59 | template <int size, bool big_endian> |
60 | class Sized_relobj_dwo; | |
61 | ||
29bd8b6b | 62 | // List of .dwo files to process. |
94e49e16 CC |
63 | struct Dwo_file_entry |
64 | { | |
65 | Dwo_file_entry(uint64_t id, std::string name) | |
66 | : dwo_id(id), dwo_name(name) | |
67 | { } | |
68 | uint64_t dwo_id; | |
69 | std::string dwo_name; | |
70 | }; | |
71 | typedef std::vector<Dwo_file_entry> File_list; | |
29bd8b6b | 72 | |
908794a9 CC |
73 | // Type to hold the offset and length of an input section |
74 | // within an output section. | |
75 | ||
76 | struct Section_bounds | |
77 | { | |
78 | section_offset_type offset; | |
79 | section_size_type size; | |
80 | ||
81 | Section_bounds() | |
82 | : offset(0), size(0) | |
83 | { } | |
84 | ||
85 | Section_bounds(section_offset_type o, section_size_type s) | |
86 | : offset(o), size(s) | |
87 | { } | |
88 | }; | |
89 | ||
90 | // A set of sections for a compilation unit or type unit. | |
91 | ||
92 | struct Unit_set | |
93 | { | |
94 | uint64_t signature; | |
95 | Section_bounds sections[elfcpp::DW_SECT_MAX + 1]; | |
96 | ||
97 | Unit_set() | |
98 | : signature(0), sections() | |
99 | { } | |
100 | }; | |
101 | ||
29bd8b6b CC |
102 | // An input file. |
103 | // This class may represent a .dwo file, a .dwp file | |
104 | // produced by an earlier run, or an executable file whose | |
105 | // debug section identifies a set of .dwo files to read. | |
106 | ||
77429909 CC |
107 | class Dwo_file |
108 | { | |
109 | public: | |
110 | Dwo_file(const char* name) | |
111 | : name_(name), obj_(NULL), input_file_(NULL), is_compressed_(), | |
908794a9 | 112 | sect_offsets_(), str_offset_map_() |
77429909 CC |
113 | { } |
114 | ||
115 | ~Dwo_file(); | |
116 | ||
29bd8b6b CC |
117 | // Read the input executable file and extract the list of .dwo files |
118 | // that it references. | |
119 | void | |
120 | read_executable(File_list* files); | |
121 | ||
77429909 CC |
122 | // Read the input file and send its contents to OUTPUT_FILE. |
123 | void | |
124 | read(Dwp_output_file* output_file); | |
125 | ||
94e49e16 CC |
126 | // Verify a .dwp file given a list of .dwo files referenced by the |
127 | // corresponding executable file. Returns true if no problems | |
128 | // were found. | |
129 | bool | |
130 | verify(const File_list& files); | |
131 | ||
77429909 CC |
132 | private: |
133 | // Types for mapping input string offsets to output string offsets. | |
134 | typedef std::pair<section_offset_type, section_offset_type> | |
135 | Str_offset_map_entry; | |
136 | typedef std::vector<Str_offset_map_entry> Str_offset_map; | |
137 | ||
138 | // A less-than comparison routine for Str_offset_map. | |
139 | struct Offset_compare | |
140 | { | |
141 | bool | |
142 | operator()(const Str_offset_map_entry& i1, | |
143 | const Str_offset_map_entry& i2) const | |
144 | { return i1.first < i2.first; } | |
145 | }; | |
146 | ||
147 | // Create a Sized_relobj_dwo of the given size and endianness, | |
148 | // and record the target info. P is a pointer to the ELF header | |
149 | // in memory. | |
150 | Relobj* | |
29bd8b6b | 151 | make_object(Dwp_output_file* output_file); |
77429909 CC |
152 | |
153 | template <int size, bool big_endian> | |
154 | Relobj* | |
155 | sized_make_object(const unsigned char* p, Input_file* input_file, | |
156 | Dwp_output_file* output_file); | |
157 | ||
158 | // Return the number of sections in the input object file. | |
159 | unsigned int | |
160 | shnum() const | |
161 | { return this->obj_->shnum(); } | |
162 | ||
163 | // Return section type. | |
164 | unsigned int | |
165 | section_type(unsigned int shndx) | |
166 | { return this->obj_->section_type(shndx); } | |
167 | ||
168 | // Get the name of a section. | |
169 | std::string | |
170 | section_name(unsigned int shndx) | |
171 | { return this->obj_->section_name(shndx); } | |
172 | ||
173 | // Return a view of the contents of a section, decompressed if necessary. | |
174 | // Set *PLEN to the size. Set *IS_NEW to true if the contents need to be | |
175 | // deleted by the caller. | |
176 | const unsigned char* | |
177 | section_contents(unsigned int shndx, section_size_type* plen, bool* is_new) | |
178 | { return this->obj_->decompressed_section_contents(shndx, plen, is_new); } | |
179 | ||
908794a9 CC |
180 | // Read the .debug_cu_index or .debug_tu_index section of a .dwp file, |
181 | // and process the CU or TU sets. | |
77429909 | 182 | void |
908794a9 CC |
183 | read_unit_index(unsigned int, unsigned int *, Dwp_output_file*, |
184 | bool is_tu_index); | |
77429909 CC |
185 | |
186 | template <bool big_endian> | |
187 | void | |
908794a9 CC |
188 | sized_read_unit_index(unsigned int, unsigned int *, Dwp_output_file*, |
189 | bool is_tu_index); | |
77429909 | 190 | |
94e49e16 CC |
191 | // Verify the .debug_cu_index section of a .dwp file, comparing it |
192 | // against the list of .dwo files referenced by the corresponding | |
193 | // executable file. | |
194 | bool | |
195 | verify_dwo_list(unsigned int, const File_list& files); | |
196 | ||
197 | template <bool big_endian> | |
198 | bool | |
199 | sized_verify_dwo_list(unsigned int, const File_list& files); | |
200 | ||
77429909 CC |
201 | // Merge the input string table section into the output file. |
202 | void | |
203 | add_strings(Dwp_output_file*, unsigned int); | |
204 | ||
205 | // Copy a section from the input file to the output file. | |
908794a9 | 206 | Section_bounds |
77429909 | 207 | copy_section(Dwp_output_file* output_file, unsigned int shndx, |
908794a9 | 208 | elfcpp::DW_SECT section_id); |
77429909 CC |
209 | |
210 | // Remap the string offsets in the .debug_str_offsets.dwo section. | |
211 | const unsigned char* | |
212 | remap_str_offsets(const unsigned char* contents, section_size_type len); | |
213 | ||
214 | template <bool big_endian> | |
215 | const unsigned char* | |
216 | sized_remap_str_offsets(const unsigned char* contents, section_size_type len); | |
217 | ||
218 | // Remap a single string offsets from an offset in the input string table | |
219 | // to an offset in the output string table. | |
220 | unsigned int | |
598c7410 | 221 | remap_str_offset(section_offset_type val); |
77429909 | 222 | |
908794a9 CC |
223 | // Add a set of .debug_info.dwo or .debug_types.dwo and related sections |
224 | // to OUTPUT_FILE. | |
77429909 | 225 | void |
908794a9 CC |
226 | add_unit_set(Dwp_output_file* output_file, unsigned int *debug_shndx, |
227 | bool is_debug_types); | |
77429909 CC |
228 | |
229 | // The filename. | |
230 | const char* name_; | |
231 | // The ELF file, represented as a gold Relobj instance. | |
232 | Relobj* obj_; | |
233 | // The Input_file object. | |
234 | Input_file* input_file_; | |
235 | // Flags indicating which sections are compressed. | |
236 | std::vector<bool> is_compressed_; | |
908794a9 CC |
237 | // Map input section index onto output section offset and size. |
238 | std::vector<Section_bounds> sect_offsets_; | |
77429909 CC |
239 | // Map input string offsets to output string offsets. |
240 | Str_offset_map str_offset_map_; | |
241 | }; | |
242 | ||
243 | // An ELF input file. | |
244 | // We derive from Sized_relobj so that we can use interfaces | |
245 | // in libgold to access the file. | |
246 | ||
247 | template <int size, bool big_endian> | |
248 | class Sized_relobj_dwo : public Sized_relobj<size, big_endian> | |
249 | { | |
250 | public: | |
251 | typedef typename elfcpp::Elf_types<size>::Elf_Addr Address; | |
252 | typedef typename Sized_relobj<size, big_endian>::Symbols Symbols; | |
253 | ||
254 | Sized_relobj_dwo(const char* name, Input_file* input_file, | |
255 | const elfcpp::Ehdr<size, big_endian>& ehdr) | |
256 | : Sized_relobj<size, big_endian>(name, input_file), | |
257 | elf_file_(this, ehdr) | |
258 | { } | |
259 | ||
260 | ~Sized_relobj_dwo() | |
261 | { } | |
262 | ||
263 | // Setup the section information. | |
264 | void | |
265 | setup(); | |
266 | ||
267 | protected: | |
268 | // Return section type. | |
269 | unsigned int | |
270 | do_section_type(unsigned int shndx) | |
271 | { return this->elf_file_.section_type(shndx); } | |
272 | ||
273 | // Get the name of a section. | |
274 | std::string | |
275 | do_section_name(unsigned int shndx) | |
276 | { return this->elf_file_.section_name(shndx); } | |
277 | ||
278 | // Get the size of a section. | |
279 | uint64_t | |
280 | do_section_size(unsigned int shndx) | |
281 | { return this->elf_file_.section_size(shndx); } | |
282 | ||
283 | // Return a view of the contents of a section. | |
284 | const unsigned char* | |
285 | do_section_contents(unsigned int, section_size_type*, bool); | |
286 | ||
287 | // Return a view of the uncompressed contents of a section. Set *PLEN | |
288 | // to the size. Set *IS_NEW to true if the contents need to be deleted | |
289 | // by the caller. | |
290 | const unsigned char* | |
291 | do_decompressed_section_contents(unsigned int shndx, | |
292 | section_size_type* plen, | |
293 | bool* is_new); | |
294 | ||
295 | // The following virtual functions are abstract in the base classes, | |
296 | // but are not used here. | |
297 | ||
298 | // Read the symbols. | |
299 | void | |
300 | do_read_symbols(Read_symbols_data*) | |
301 | { gold_unreachable(); } | |
302 | ||
303 | // Lay out the input sections. | |
304 | void | |
305 | do_layout(Symbol_table*, Layout*, Read_symbols_data*) | |
306 | { gold_unreachable(); } | |
307 | ||
308 | // Layout sections whose layout was deferred while waiting for | |
309 | // input files from a plugin. | |
310 | void | |
311 | do_layout_deferred_sections(Layout*) | |
312 | { gold_unreachable(); } | |
313 | ||
314 | // Add the symbols to the symbol table. | |
315 | void | |
316 | do_add_symbols(Symbol_table*, Read_symbols_data*, Layout*) | |
317 | { gold_unreachable(); } | |
318 | ||
319 | Archive::Should_include | |
320 | do_should_include_member(Symbol_table*, Layout*, Read_symbols_data*, | |
321 | std::string*) | |
322 | { gold_unreachable(); } | |
323 | ||
324 | // Iterate over global symbols, calling a visitor class V for each. | |
325 | void | |
326 | do_for_all_global_symbols(Read_symbols_data*, | |
327 | Library_base::Symbol_visitor_base*) | |
328 | { gold_unreachable(); } | |
329 | ||
330 | // Return section flags. | |
331 | uint64_t | |
332 | do_section_flags(unsigned int) | |
333 | { gold_unreachable(); } | |
334 | ||
335 | // Return section entsize. | |
336 | uint64_t | |
337 | do_section_entsize(unsigned int) | |
338 | { gold_unreachable(); } | |
339 | ||
340 | // Return section address. | |
341 | uint64_t | |
342 | do_section_address(unsigned int) | |
343 | { gold_unreachable(); } | |
344 | ||
345 | // Return the section link field. | |
346 | unsigned int | |
347 | do_section_link(unsigned int) | |
348 | { gold_unreachable(); } | |
349 | ||
350 | // Return the section link field. | |
351 | unsigned int | |
352 | do_section_info(unsigned int) | |
353 | { gold_unreachable(); } | |
354 | ||
355 | // Return the section alignment. | |
356 | uint64_t | |
357 | do_section_addralign(unsigned int) | |
358 | { gold_unreachable(); } | |
359 | ||
360 | // Return the Xindex structure to use. | |
361 | Xindex* | |
362 | do_initialize_xindex() | |
363 | { gold_unreachable(); } | |
364 | ||
365 | // Get symbol counts. | |
366 | void | |
367 | do_get_global_symbol_counts(const Symbol_table*, size_t*, size_t*) const | |
368 | { gold_unreachable(); } | |
369 | ||
370 | // Get global symbols. | |
371 | const Symbols* | |
372 | do_get_global_symbols() const | |
373 | { return NULL; } | |
374 | ||
375 | // Return the value of a local symbol. | |
376 | uint64_t | |
377 | do_local_symbol_value(unsigned int, uint64_t) const | |
378 | { gold_unreachable(); } | |
379 | ||
380 | unsigned int | |
381 | do_local_plt_offset(unsigned int) const | |
382 | { gold_unreachable(); } | |
383 | ||
384 | // Return whether local symbol SYMNDX is a TLS symbol. | |
385 | bool | |
386 | do_local_is_tls(unsigned int) const | |
387 | { gold_unreachable(); } | |
388 | ||
389 | // Return the number of local symbols. | |
390 | unsigned int | |
391 | do_local_symbol_count() const | |
392 | { gold_unreachable(); } | |
393 | ||
394 | // Return the number of local symbols in the output symbol table. | |
395 | unsigned int | |
396 | do_output_local_symbol_count() const | |
397 | { gold_unreachable(); } | |
398 | ||
399 | // Return the file offset for local symbols in the output symbol table. | |
400 | off_t | |
401 | do_local_symbol_offset() const | |
402 | { gold_unreachable(); } | |
403 | ||
404 | // Read the relocs. | |
405 | void | |
406 | do_read_relocs(Read_relocs_data*) | |
407 | { gold_unreachable(); } | |
408 | ||
409 | // Process the relocs to find list of referenced sections. Used only | |
410 | // during garbage collection. | |
411 | void | |
412 | do_gc_process_relocs(Symbol_table*, Layout*, Read_relocs_data*) | |
413 | { gold_unreachable(); } | |
414 | ||
415 | // Scan the relocs and adjust the symbol table. | |
416 | void | |
417 | do_scan_relocs(Symbol_table*, Layout*, Read_relocs_data*) | |
418 | { gold_unreachable(); } | |
419 | ||
420 | // Count the local symbols. | |
421 | void | |
422 | do_count_local_symbols(Stringpool_template<char>*, | |
423 | Stringpool_template<char>*) | |
424 | { gold_unreachable(); } | |
425 | ||
426 | // Finalize the local symbols. | |
427 | unsigned int | |
428 | do_finalize_local_symbols(unsigned int, off_t, Symbol_table*) | |
429 | { gold_unreachable(); } | |
430 | ||
431 | // Set the offset where local dynamic symbol information will be stored. | |
432 | unsigned int | |
433 | do_set_local_dynsym_indexes(unsigned int) | |
434 | { gold_unreachable(); } | |
435 | ||
436 | // Set the offset where local dynamic symbol information will be stored. | |
437 | unsigned int | |
438 | do_set_local_dynsym_offset(off_t) | |
439 | { gold_unreachable(); } | |
440 | ||
441 | // Relocate the input sections and write out the local symbols. | |
442 | void | |
443 | do_relocate(const Symbol_table*, const Layout*, Output_file*) | |
444 | { gold_unreachable(); } | |
445 | ||
446 | private: | |
447 | // General access to the ELF file. | |
448 | elfcpp::Elf_file<size, big_endian, Object> elf_file_; | |
449 | }; | |
450 | ||
451 | // The output file. | |
452 | // This class is responsible for collecting the debug index information | |
453 | // and writing the .dwp file in ELF format. | |
454 | ||
455 | class Dwp_output_file | |
456 | { | |
457 | public: | |
458 | Dwp_output_file(const char* name) | |
459 | : name_(name), machine_(0), size_(0), big_endian_(false), osabi_(0), | |
460 | abiversion_(0), fd_(NULL), next_file_offset_(0), shnum_(1), sections_(), | |
908794a9 CC |
461 | section_id_map_(), shoff_(0), shstrndx_(0), have_strings_(false), |
462 | stringpool_(), shstrtab_(), cu_index_(), tu_index_(), last_type_sig_(0), | |
77429909 CC |
463 | last_tu_slot_(0) |
464 | { | |
908794a9 | 465 | this->section_id_map_.resize(elfcpp::DW_SECT_MAX + 1); |
77429909 CC |
466 | this->stringpool_.set_no_zero_null(); |
467 | } | |
468 | ||
469 | // Record the target info from an input file. | |
470 | void | |
471 | record_target_info(const char* name, int machine, int size, bool big_endian, | |
472 | int osabi, int abiversion); | |
473 | ||
474 | // Add a string to the debug strings section. | |
475 | section_offset_type | |
476 | add_string(const char* str, size_t len); | |
477 | ||
908794a9 CC |
478 | // Add a section to the output file, and return the new section offset. |
479 | section_offset_type | |
480 | add_contribution(elfcpp::DW_SECT section_id, const unsigned char* contents, | |
481 | section_size_type len, int align); | |
77429909 CC |
482 | |
483 | // Add a set of .debug_info and related sections to the output file. | |
484 | void | |
908794a9 | 485 | add_cu_set(Unit_set* cu_set); |
77429909 CC |
486 | |
487 | // Lookup a type signature and return TRUE if we have already seen it. | |
488 | bool | |
489 | lookup_tu(uint64_t type_sig); | |
490 | ||
491 | // Add a set of .debug_types and related sections to the output file. | |
492 | void | |
908794a9 | 493 | add_tu_set(Unit_set* tu_set); |
77429909 CC |
494 | |
495 | // Finalize the file, write the string tables and index sections, | |
496 | // and close the file. | |
497 | void | |
498 | finalize(); | |
499 | ||
500 | private: | |
908794a9 CC |
501 | // Contributions to output sections. |
502 | struct Contribution | |
503 | { | |
504 | section_offset_type output_offset; | |
505 | section_size_type size; | |
506 | const unsigned char* contents; | |
507 | }; | |
508 | ||
77429909 CC |
509 | // Sections in the output file. |
510 | struct Section | |
511 | { | |
512 | const char* name; | |
513 | off_t offset; | |
514 | section_size_type size; | |
515 | int align; | |
908794a9 | 516 | std::vector<Contribution> contributions; |
77429909 | 517 | |
908794a9 CC |
518 | Section(const char* n, int a) |
519 | : name(n), offset(0), size(0), align(a), contributions() | |
520 | { } | |
77429909 CC |
521 | }; |
522 | ||
523 | // The index sections defined by the DWARF Package File Format spec. | |
524 | class Dwp_index | |
525 | { | |
526 | public: | |
908794a9 CC |
527 | // Vector for the section table. |
528 | typedef std::vector<const Unit_set*> Section_table; | |
77429909 CC |
529 | |
530 | Dwp_index() | |
908794a9 CC |
531 | : capacity_(0), used_(0), hash_table_(NULL), section_table_(), |
532 | section_mask_(0) | |
77429909 CC |
533 | { } |
534 | ||
535 | ~Dwp_index() | |
536 | { } | |
537 | ||
538 | // Find a slot in the hash table for SIGNATURE. Return TRUE | |
539 | // if the entry already exists. | |
540 | bool | |
541 | find_or_add(uint64_t signature, unsigned int* slotp); | |
542 | ||
543 | // Enter a CU or TU set at the given SLOT in the hash table. | |
544 | void | |
908794a9 | 545 | enter_set(unsigned int slot, const Unit_set* set); |
77429909 CC |
546 | |
547 | // Return the contents of the given SLOT in the hash table of signatures. | |
548 | uint64_t | |
549 | hash_table(unsigned int slot) const | |
550 | { return this->hash_table_[slot]; } | |
551 | ||
552 | // Return the contents of the given SLOT in the parallel table of | |
553 | // shndx pool indexes. | |
554 | uint32_t | |
555 | index_table(unsigned int slot) const | |
556 | { return this->index_table_[slot]; } | |
557 | ||
558 | // Return the total number of slots in the hash table. | |
559 | unsigned int | |
560 | hash_table_total_slots() const | |
561 | { return this->capacity_; } | |
562 | ||
563 | // Return the number of used slots in the hash table. | |
564 | unsigned int | |
565 | hash_table_used_slots() const | |
566 | { return this->used_; } | |
567 | ||
568 | // Return an iterator into the shndx pool. | |
908794a9 CC |
569 | Section_table::const_iterator |
570 | section_table() const | |
571 | { return this->section_table_.begin(); } | |
77429909 | 572 | |
908794a9 CC |
573 | Section_table::const_iterator |
574 | section_table_end() const | |
575 | { return this->section_table_.end(); } | |
77429909 | 576 | |
908794a9 | 577 | // Return the number of rows in the section table. |
77429909 | 578 | unsigned int |
908794a9 CC |
579 | section_table_rows() const |
580 | { return this->section_table_.size(); } | |
581 | ||
582 | // Return the mask indicating which columns will be used | |
583 | // in the section table. | |
584 | int | |
585 | section_table_cols() const | |
586 | { return this->section_mask_; } | |
77429909 CC |
587 | |
588 | private: | |
589 | // Initialize the hash table. | |
590 | void | |
591 | initialize(); | |
592 | ||
593 | // Grow the hash table when we reach 2/3 capacity. | |
594 | void | |
595 | grow(); | |
596 | ||
597 | // The number of slots in the table, a power of 2 such that | |
598 | // capacity > 3 * size / 2. | |
599 | unsigned int capacity_; | |
600 | // The current number of used slots in the hash table. | |
601 | unsigned int used_; | |
602 | // The storage for the hash table of signatures. | |
603 | uint64_t* hash_table_; | |
604 | // The storage for the parallel table of shndx pool indexes. | |
605 | uint32_t* index_table_; | |
908794a9 CC |
606 | // The table of section offsets and sizes. |
607 | Section_table section_table_; | |
608 | // Bit mask to indicate which debug sections are present in the file. | |
609 | int section_mask_; | |
77429909 CC |
610 | }; // End class Dwp_output_file::Dwp_index. |
611 | ||
908794a9 CC |
612 | // Add a new output section and return the section index. |
613 | unsigned int | |
614 | add_output_section(const char* section_name, int align); | |
615 | ||
616 | // Write a new section to the output file. | |
77429909 | 617 | void |
908794a9 CC |
618 | write_new_section(const char* section_name, const unsigned char* contents, |
619 | section_size_type len, int align); | |
77429909 CC |
620 | |
621 | // Write the ELF header. | |
622 | void | |
623 | write_ehdr(); | |
624 | ||
625 | template<unsigned int size, bool big_endian> | |
626 | void | |
627 | sized_write_ehdr(); | |
628 | ||
629 | // Write a section header. | |
630 | void | |
631 | write_shdr(const char* name, unsigned int type, unsigned int flags, | |
632 | uint64_t addr, off_t offset, section_size_type sect_size, | |
633 | unsigned int link, unsigned int info, | |
634 | unsigned int align, unsigned int ent_size); | |
635 | ||
636 | template<unsigned int size, bool big_endian> | |
637 | void | |
638 | sized_write_shdr(const char* name, unsigned int type, unsigned int flags, | |
639 | uint64_t addr, off_t offset, section_size_type sect_size, | |
640 | unsigned int link, unsigned int info, | |
641 | unsigned int align, unsigned int ent_size); | |
642 | ||
908794a9 CC |
643 | // Write the contributions to an output section. |
644 | void | |
645 | write_contributions(const Section& sect); | |
646 | ||
77429909 CC |
647 | // Write a CU or TU index section. |
648 | template<bool big_endian> | |
649 | void | |
650 | write_index(const char* sect_name, const Dwp_index& index); | |
651 | ||
652 | // The output filename. | |
653 | const char* name_; | |
654 | // ELF header parameters. | |
655 | int machine_; | |
656 | int size_; | |
657 | int big_endian_; | |
658 | int osabi_; | |
659 | int abiversion_; | |
660 | // The output file descriptor. | |
661 | FILE* fd_; | |
662 | // Next available file offset. | |
663 | off_t next_file_offset_; | |
664 | // The number of sections. | |
665 | unsigned int shnum_; | |
666 | // Section table. The first entry is shndx 1. | |
667 | std::vector<Section> sections_; | |
908794a9 CC |
668 | // Section id map. This maps a DW_SECT enum to an shndx. |
669 | std::vector<unsigned int> section_id_map_; | |
77429909 CC |
670 | // File offset of the section header table. |
671 | off_t shoff_; | |
672 | // Section index of the section string table. | |
673 | unsigned int shstrndx_; | |
674 | // TRUE if we have added any strings to the string pool. | |
675 | bool have_strings_; | |
676 | // String pool for the output .debug_str.dwo section. | |
677 | Stringpool stringpool_; | |
678 | // String pool for the .shstrtab section. | |
679 | Stringpool shstrtab_; | |
680 | // The compilation unit index. | |
681 | Dwp_index cu_index_; | |
682 | // The type unit index. | |
683 | Dwp_index tu_index_; | |
684 | // Cache of the last type signature looked up. | |
685 | uint64_t last_type_sig_; | |
686 | // Cache of the slot index for the last type signature. | |
687 | unsigned int last_tu_slot_; | |
688 | }; | |
689 | ||
29bd8b6b CC |
690 | // A specialization of Dwarf_info_reader, for reading dwo_names from |
691 | // DWARF CUs. | |
692 | ||
693 | class Dwo_name_info_reader : public Dwarf_info_reader | |
694 | { | |
695 | public: | |
696 | Dwo_name_info_reader(Relobj* object, unsigned int shndx) | |
697 | : Dwarf_info_reader(false, object, NULL, 0, shndx, 0, 0), | |
698 | files_(NULL) | |
699 | { } | |
700 | ||
701 | ~Dwo_name_info_reader() | |
702 | { } | |
703 | ||
704 | // Get the dwo_names from the DWARF compilation unit DIEs. | |
705 | void | |
706 | get_dwo_names(File_list* files) | |
707 | { | |
708 | this->files_ = files; | |
709 | this->parse(); | |
710 | } | |
711 | ||
712 | protected: | |
713 | // Visit a compilation unit. | |
714 | virtual void | |
715 | visit_compilation_unit(off_t cu_offset, off_t cu_length, Dwarf_die*); | |
716 | ||
717 | private: | |
718 | // The list of files to populate. | |
719 | File_list* files_; | |
720 | }; | |
721 | ||
908794a9 CC |
722 | // A specialization of Dwarf_info_reader, for reading DWARF CUs and TUs |
723 | // and adding them to the output file. | |
77429909 | 724 | |
908794a9 | 725 | class Unit_reader : public Dwarf_info_reader |
77429909 CC |
726 | { |
727 | public: | |
908794a9 | 728 | Unit_reader(bool is_type_unit, Relobj* object, unsigned int shndx) |
29bd8b6b | 729 | : Dwarf_info_reader(is_type_unit, object, NULL, 0, shndx, 0, 0), |
908794a9 | 730 | output_file_(NULL), sections_(NULL) |
77429909 CC |
731 | { } |
732 | ||
908794a9 | 733 | ~Unit_reader() |
77429909 CC |
734 | { } |
735 | ||
908794a9 CC |
736 | // Read the CUs or TUs and add them to the output file. |
737 | void | |
738 | add_units(Dwp_output_file*, unsigned int debug_abbrev, Section_bounds*); | |
77429909 CC |
739 | |
740 | protected: | |
741 | // Visit a compilation unit. | |
742 | virtual void | |
743 | visit_compilation_unit(off_t cu_offset, off_t cu_length, Dwarf_die*); | |
744 | ||
745 | // Visit a type unit. | |
746 | virtual void | |
908794a9 CC |
747 | visit_type_unit(off_t tu_offset, off_t tu_length, off_t type_offset, |
748 | uint64_t signature, Dwarf_die*); | |
77429909 CC |
749 | |
750 | private: | |
908794a9 CC |
751 | Dwp_output_file* output_file_; |
752 | Section_bounds* sections_; | |
77429909 CC |
753 | }; |
754 | ||
908794a9 CC |
755 | // Return the name of a DWARF .dwo section. |
756 | ||
757 | static const char* | |
758 | get_dwarf_section_name(elfcpp::DW_SECT section_id) | |
759 | { | |
760 | static const char* dwarf_section_names[] = { | |
761 | NULL, // unused | |
762 | ".debug_info.dwo", // DW_SECT_INFO = 1 | |
763 | ".debug_types.dwo", // DW_SECT_TYPES = 2 | |
764 | ".debug_abbrev.dwo", // DW_SECT_ABBREV = 3 | |
765 | ".debug_line.dwo", // DW_SECT_LINE = 4 | |
766 | ".debug_loc.dwo", // DW_SECT_LOC = 5 | |
767 | ".debug_str_offsets.dwo", // DW_SECT_STR_OFFSETS = 6 | |
768 | ".debug_macinfo.dwo", // DW_SECT_MACINFO = 7 | |
769 | ".debug_macro.dwo", // DW_SECT_MACRO = 8 | |
770 | }; | |
771 | ||
772 | gold_assert(section_id > 0 && section_id <= elfcpp::DW_SECT_MAX); | |
773 | return dwarf_section_names[section_id]; | |
774 | } | |
775 | ||
77429909 CC |
776 | // Class Sized_relobj_dwo. |
777 | ||
778 | // Setup the section information. | |
779 | ||
780 | template <int size, bool big_endian> | |
781 | void | |
782 | Sized_relobj_dwo<size, big_endian>::setup() | |
783 | { | |
784 | const unsigned int shnum = this->elf_file_.shnum(); | |
785 | this->set_shnum(shnum); | |
786 | this->section_offsets().resize(shnum); | |
787 | } | |
788 | ||
789 | // Return a view of the contents of a section. | |
790 | ||
791 | template <int size, bool big_endian> | |
792 | const unsigned char* | |
793 | Sized_relobj_dwo<size, big_endian>::do_section_contents( | |
794 | unsigned int shndx, | |
795 | section_size_type* plen, | |
796 | bool cache) | |
797 | { | |
798 | Object::Location loc(this->elf_file_.section_contents(shndx)); | |
799 | *plen = convert_to_section_size_type(loc.data_size); | |
800 | if (*plen == 0) | |
801 | { | |
802 | static const unsigned char empty[1] = { '\0' }; | |
803 | return empty; | |
804 | } | |
805 | return this->get_view(loc.file_offset, *plen, true, cache); | |
806 | } | |
807 | ||
808 | // Return a view of the uncompressed contents of a section. Set *PLEN | |
809 | // to the size. Set *IS_NEW to true if the contents need to be deleted | |
810 | // by the caller. | |
811 | ||
812 | template <int size, bool big_endian> | |
813 | const unsigned char* | |
814 | Sized_relobj_dwo<size, big_endian>::do_decompressed_section_contents( | |
815 | unsigned int shndx, | |
816 | section_size_type* plen, | |
817 | bool* is_new) | |
818 | { | |
819 | section_size_type buffer_size; | |
820 | const unsigned char* buffer = this->do_section_contents(shndx, &buffer_size, | |
821 | false); | |
822 | ||
823 | std::string sect_name = this->do_section_name(shndx); | |
824 | if (!is_prefix_of(".zdebug_", sect_name.c_str())) | |
825 | { | |
826 | *plen = buffer_size; | |
827 | *is_new = false; | |
828 | return buffer; | |
829 | } | |
830 | ||
831 | section_size_type uncompressed_size = get_uncompressed_size(buffer, | |
832 | buffer_size); | |
833 | unsigned char* uncompressed_data = new unsigned char[uncompressed_size]; | |
834 | if (!decompress_input_section(buffer, | |
835 | buffer_size, | |
836 | uncompressed_data, | |
837 | uncompressed_size)) | |
838 | this->error(_("could not decompress section %s"), | |
839 | this->section_name(shndx).c_str()); | |
840 | *plen = uncompressed_size; | |
841 | *is_new = true; | |
842 | return uncompressed_data; | |
843 | } | |
844 | ||
845 | // Class Dwo_file. | |
846 | ||
847 | Dwo_file::~Dwo_file() | |
848 | { | |
77429909 CC |
849 | if (this->obj_ != NULL) |
850 | delete this->obj_; | |
29bd8b6b CC |
851 | if (this->input_file_ != NULL) |
852 | delete this->input_file_; | |
853 | } | |
854 | ||
855 | // Read the input executable file and extract the list of .dwo files | |
856 | // that it references. | |
857 | ||
858 | void | |
859 | Dwo_file::read_executable(File_list* files) | |
860 | { | |
861 | this->obj_ = this->make_object(NULL); | |
862 | ||
863 | unsigned int shnum = this->shnum(); | |
864 | this->is_compressed_.resize(shnum); | |
908794a9 | 865 | this->sect_offsets_.resize(shnum); |
29bd8b6b CC |
866 | |
867 | unsigned int debug_info = 0; | |
868 | unsigned int debug_abbrev = 0; | |
869 | ||
870 | // Scan the section table and collect the debug sections we need. | |
871 | // (Section index 0 is a dummy section; skip it.) | |
872 | for (unsigned int i = 1; i < shnum; i++) | |
873 | { | |
874 | if (this->section_type(i) != elfcpp::SHT_PROGBITS) | |
875 | continue; | |
876 | std::string sect_name = this->section_name(i); | |
877 | const char* suffix = sect_name.c_str(); | |
878 | if (is_prefix_of(".debug_", suffix)) | |
879 | suffix += 7; | |
880 | else if (is_prefix_of(".zdebug_", suffix)) | |
881 | { | |
882 | this->is_compressed_[i] = true; | |
883 | suffix += 8; | |
884 | } | |
885 | else | |
886 | continue; | |
887 | if (strcmp(suffix, "info") == 0) | |
888 | debug_info = i; | |
889 | else if (strcmp(suffix, "abbrev") == 0) | |
890 | debug_abbrev = i; | |
891 | } | |
892 | ||
893 | if (debug_info > 0) | |
894 | { | |
895 | Dwo_name_info_reader dwarf_reader(this->obj_, debug_info); | |
896 | dwarf_reader.set_abbrev_shndx(debug_abbrev); | |
897 | dwarf_reader.get_dwo_names(files); | |
898 | } | |
77429909 CC |
899 | } |
900 | ||
901 | // Read the input file and send its contents to OUTPUT_FILE. | |
902 | ||
903 | void | |
904 | Dwo_file::read(Dwp_output_file* output_file) | |
905 | { | |
29bd8b6b | 906 | this->obj_ = this->make_object(output_file); |
77429909 CC |
907 | |
908 | unsigned int shnum = this->shnum(); | |
909 | this->is_compressed_.resize(shnum); | |
908794a9 | 910 | this->sect_offsets_.resize(shnum); |
77429909 CC |
911 | |
912 | typedef std::vector<unsigned int> Types_list; | |
913 | Types_list debug_types; | |
908794a9 CC |
914 | unsigned int debug_shndx[elfcpp::DW_SECT_MAX + 1]; |
915 | for (unsigned int i = 0; i <= elfcpp::DW_SECT_MAX; i++) | |
916 | debug_shndx[i] = 0; | |
77429909 | 917 | unsigned int debug_str = 0; |
77429909 CC |
918 | unsigned int debug_cu_index = 0; |
919 | unsigned int debug_tu_index = 0; | |
920 | ||
908794a9 | 921 | // Scan the section table and collect debug sections. |
77429909 CC |
922 | // (Section index 0 is a dummy section; skip it.) |
923 | for (unsigned int i = 1; i < shnum; i++) | |
924 | { | |
925 | if (this->section_type(i) != elfcpp::SHT_PROGBITS) | |
926 | continue; | |
927 | std::string sect_name = this->section_name(i); | |
928 | const char* suffix = sect_name.c_str(); | |
929 | if (is_prefix_of(".debug_", suffix)) | |
930 | suffix += 7; | |
931 | else if (is_prefix_of(".zdebug_", suffix)) | |
932 | { | |
933 | this->is_compressed_[i] = true; | |
934 | suffix += 8; | |
935 | } | |
936 | else | |
937 | continue; | |
908794a9 CC |
938 | if (strcmp(suffix, "info.dwo") == 0) |
939 | debug_shndx[elfcpp::DW_SECT_INFO] = i; | |
940 | else if (strcmp(suffix, "types.dwo") == 0) | |
941 | debug_types.push_back(i); | |
942 | else if (strcmp(suffix, "abbrev.dwo") == 0) | |
943 | debug_shndx[elfcpp::DW_SECT_ABBREV] = i; | |
944 | else if (strcmp(suffix, "line.dwo") == 0) | |
945 | debug_shndx[elfcpp::DW_SECT_LINE] = i; | |
946 | else if (strcmp(suffix, "loc.dwo") == 0) | |
947 | debug_shndx[elfcpp::DW_SECT_LOC] = i; | |
948 | else if (strcmp(suffix, "str.dwo") == 0) | |
949 | debug_str = i; | |
950 | else if (strcmp(suffix, "str_offsets.dwo") == 0) | |
951 | debug_shndx[elfcpp::DW_SECT_STR_OFFSETS] = i; | |
952 | else if (strcmp(suffix, "macinfo.dwo") == 0) | |
953 | debug_shndx[elfcpp::DW_SECT_MACINFO] = i; | |
954 | else if (strcmp(suffix, "macro.dwo") == 0) | |
955 | debug_shndx[elfcpp::DW_SECT_MACRO] = i; | |
956 | else if (strcmp(suffix, "cu_index") == 0) | |
77429909 CC |
957 | debug_cu_index = i; |
958 | else if (strcmp(suffix, "tu_index") == 0) | |
959 | debug_tu_index = i; | |
77429909 CC |
960 | } |
961 | ||
962 | // Merge the input string table into the output string table. | |
963 | this->add_strings(output_file, debug_str); | |
964 | ||
965 | // If we found any .dwp index sections, read those and add the section | |
966 | // sets to the output file. | |
967 | if (debug_cu_index > 0 || debug_tu_index > 0) | |
968 | { | |
969 | if (debug_cu_index > 0) | |
908794a9 | 970 | this->read_unit_index(debug_cu_index, debug_shndx, output_file, false); |
77429909 | 971 | if (debug_tu_index > 0) |
908794a9 CC |
972 | { |
973 | if (debug_types.size() != 1) | |
974 | gold_fatal(_("%s: .dwp file must have exactly one " | |
975 | ".debug_types.dwo section"), this->name_); | |
976 | debug_shndx[elfcpp::DW_SECT_TYPES] = debug_types[0]; | |
977 | this->read_unit_index(debug_tu_index, debug_shndx, output_file, true); | |
978 | } | |
77429909 CC |
979 | return; |
980 | } | |
981 | ||
982 | // If we found no index sections, this is a .dwo file. | |
908794a9 CC |
983 | if (debug_shndx[elfcpp::DW_SECT_INFO] > 0) |
984 | this->add_unit_set(output_file, debug_shndx, false); | |
77429909 | 985 | |
908794a9 | 986 | debug_shndx[elfcpp::DW_SECT_INFO] = 0; |
77429909 CC |
987 | for (Types_list::const_iterator tp = debug_types.begin(); |
988 | tp != debug_types.end(); | |
989 | ++tp) | |
990 | { | |
908794a9 CC |
991 | debug_shndx[elfcpp::DW_SECT_TYPES] = *tp; |
992 | this->add_unit_set(output_file, debug_shndx, true); | |
77429909 CC |
993 | } |
994 | } | |
995 | ||
94e49e16 CC |
996 | // Verify a .dwp file given a list of .dwo files referenced by the |
997 | // corresponding executable file. Returns true if no problems | |
998 | // were found. | |
999 | ||
1000 | bool | |
1001 | Dwo_file::verify(const File_list& files) | |
1002 | { | |
1003 | this->obj_ = this->make_object(NULL); | |
1004 | ||
1005 | unsigned int shnum = this->shnum(); | |
1006 | this->is_compressed_.resize(shnum); | |
1007 | this->sect_offsets_.resize(shnum); | |
1008 | ||
1009 | unsigned int debug_cu_index = 0; | |
1010 | ||
1011 | // Scan the section table and collect debug sections. | |
1012 | // (Section index 0 is a dummy section; skip it.) | |
1013 | for (unsigned int i = 1; i < shnum; i++) | |
1014 | { | |
1015 | if (this->section_type(i) != elfcpp::SHT_PROGBITS) | |
1016 | continue; | |
1017 | std::string sect_name = this->section_name(i); | |
1018 | const char* suffix = sect_name.c_str(); | |
1019 | if (is_prefix_of(".debug_", suffix)) | |
1020 | suffix += 7; | |
1021 | else if (is_prefix_of(".zdebug_", suffix)) | |
1022 | { | |
1023 | this->is_compressed_[i] = true; | |
1024 | suffix += 8; | |
1025 | } | |
1026 | else | |
1027 | continue; | |
1028 | if (strcmp(suffix, "cu_index") == 0) | |
1029 | debug_cu_index = i; | |
1030 | } | |
1031 | ||
1032 | if (debug_cu_index == 0) | |
1033 | gold_fatal(_("%s: no .debug_cu_index section found"), this->name_); | |
1034 | ||
1035 | return this->verify_dwo_list(debug_cu_index, files); | |
1036 | } | |
1037 | ||
77429909 | 1038 | // Create a Sized_relobj_dwo of the given size and endianness, |
29bd8b6b | 1039 | // and record the target info. |
77429909 CC |
1040 | |
1041 | Relobj* | |
29bd8b6b | 1042 | Dwo_file::make_object(Dwp_output_file* output_file) |
77429909 | 1043 | { |
29bd8b6b CC |
1044 | // Open the input file. |
1045 | Input_file* input_file = new Input_file(this->name_); | |
1046 | this->input_file_ = input_file; | |
1047 | Dirsearch dirpath; | |
1048 | int index; | |
1049 | if (!input_file->open(dirpath, NULL, &index)) | |
1050 | gold_fatal(_("%s: can't open"), this->name_); | |
1051 | ||
1052 | // Check that it's an ELF file. | |
1053 | off_t filesize = input_file->file().filesize(); | |
1054 | int hdrsize = elfcpp::Elf_recognizer::max_header_size; | |
1055 | if (filesize < hdrsize) | |
1056 | hdrsize = filesize; | |
1057 | const unsigned char* elf_header = | |
1058 | input_file->file().get_view(0, 0, hdrsize, true, false); | |
1059 | if (!elfcpp::Elf_recognizer::is_elf_file(elf_header, hdrsize)) | |
1060 | gold_fatal(_("%s: not an ELF object file"), this->name_); | |
1061 | ||
1062 | // Get the size, endianness, machine, etc. info from the header, | |
1063 | // make an appropriately-sized Relobj, and pass the target info | |
1064 | // to the output object. | |
1065 | int size; | |
1066 | bool big_endian; | |
1067 | std::string error; | |
1068 | if (!elfcpp::Elf_recognizer::is_valid_header(elf_header, hdrsize, &size, | |
1069 | &big_endian, &error)) | |
1070 | gold_fatal(_("%s: %s"), this->name_, error.c_str()); | |
1071 | ||
77429909 CC |
1072 | if (size == 32) |
1073 | { | |
1074 | if (big_endian) | |
1075 | #ifdef HAVE_TARGET_32_BIG | |
29bd8b6b CC |
1076 | return this->sized_make_object<32, true>(elf_header, input_file, |
1077 | output_file); | |
77429909 CC |
1078 | #else |
1079 | gold_unreachable(); | |
1080 | #endif | |
1081 | else | |
1082 | #ifdef HAVE_TARGET_32_LITTLE | |
29bd8b6b CC |
1083 | return this->sized_make_object<32, false>(elf_header, input_file, |
1084 | output_file); | |
77429909 CC |
1085 | #else |
1086 | gold_unreachable(); | |
1087 | #endif | |
1088 | } | |
1089 | else if (size == 64) | |
1090 | { | |
1091 | if (big_endian) | |
1092 | #ifdef HAVE_TARGET_64_BIG | |
29bd8b6b CC |
1093 | return this->sized_make_object<64, true>(elf_header, input_file, |
1094 | output_file); | |
77429909 CC |
1095 | #else |
1096 | gold_unreachable(); | |
1097 | #endif | |
1098 | else | |
1099 | #ifdef HAVE_TARGET_64_LITTLE | |
29bd8b6b CC |
1100 | return this->sized_make_object<64, false>(elf_header, input_file, |
1101 | output_file); | |
77429909 CC |
1102 | #else |
1103 | gold_unreachable(); | |
1104 | #endif | |
1105 | } | |
1106 | else | |
1107 | gold_unreachable(); | |
1108 | } | |
1109 | ||
1110 | // Function template to create a Sized_relobj_dwo and record the target info. | |
1111 | // P is a pointer to the ELF header in memory. | |
1112 | ||
1113 | template <int size, bool big_endian> | |
1114 | Relobj* | |
1115 | Dwo_file::sized_make_object(const unsigned char* p, Input_file* input_file, | |
1116 | Dwp_output_file* output_file) | |
1117 | { | |
1118 | elfcpp::Ehdr<size, big_endian> ehdr(p); | |
1119 | Sized_relobj_dwo<size, big_endian>* obj = | |
1120 | new Sized_relobj_dwo<size, big_endian>(this->name_, input_file, ehdr); | |
1121 | obj->setup(); | |
29bd8b6b CC |
1122 | if (output_file != NULL) |
1123 | output_file->record_target_info( | |
1124 | this->name_, ehdr.get_e_machine(), size, big_endian, | |
1125 | ehdr.get_e_ident()[elfcpp::EI_OSABI], | |
1126 | ehdr.get_e_ident()[elfcpp::EI_ABIVERSION]); | |
77429909 CC |
1127 | return obj; |
1128 | } | |
1129 | ||
908794a9 CC |
1130 | // Read the .debug_cu_index or .debug_tu_index section of a .dwp file, |
1131 | // and process the CU or TU sets. | |
77429909 CC |
1132 | |
1133 | void | |
908794a9 CC |
1134 | Dwo_file::read_unit_index(unsigned int shndx, unsigned int *debug_shndx, |
1135 | Dwp_output_file* output_file, bool is_tu_index) | |
77429909 CC |
1136 | { |
1137 | if (this->obj_->is_big_endian()) | |
908794a9 CC |
1138 | this->sized_read_unit_index<true>(shndx, debug_shndx, output_file, |
1139 | is_tu_index); | |
77429909 | 1140 | else |
908794a9 CC |
1141 | this->sized_read_unit_index<false>(shndx, debug_shndx, output_file, |
1142 | is_tu_index); | |
77429909 CC |
1143 | } |
1144 | ||
1145 | template <bool big_endian> | |
1146 | void | |
908794a9 CC |
1147 | Dwo_file::sized_read_unit_index(unsigned int shndx, |
1148 | unsigned int *debug_shndx, | |
1149 | Dwp_output_file* output_file, | |
1150 | bool is_tu_index) | |
77429909 | 1151 | { |
908794a9 CC |
1152 | elfcpp::DW_SECT info_sect = (is_tu_index |
1153 | ? elfcpp::DW_SECT_TYPES | |
1154 | : elfcpp::DW_SECT_INFO); | |
1155 | unsigned int info_shndx = debug_shndx[info_sect]; | |
1156 | ||
1157 | gold_assert(shndx > 0 && info_shndx > 0); | |
1158 | ||
1159 | section_size_type index_len; | |
1160 | bool index_is_new; | |
1161 | const unsigned char* contents = | |
1162 | this->section_contents(shndx, &index_len, &index_is_new); | |
77429909 CC |
1163 | |
1164 | unsigned int version = | |
1165 | elfcpp::Swap_unaligned<32, big_endian>::readval(contents); | |
77429909 | 1166 | |
908794a9 CC |
1167 | // We don't support version 1 anymore because it was experimental |
1168 | // and because in normal use, dwp is not expected to read .dwp files | |
1169 | // produced by an earlier version of the tool. | |
1170 | if (version != 2) | |
1171 | gold_fatal(_("%s: section %s has unsupported version number %d"), | |
1172 | this->name_, this->section_name(shndx).c_str(), version); | |
1173 | ||
1174 | unsigned int ncols = | |
1175 | elfcpp::Swap_unaligned<32, big_endian>::readval(contents | |
1176 | + sizeof(uint32_t)); | |
77429909 CC |
1177 | unsigned int nused = |
1178 | elfcpp::Swap_unaligned<32, big_endian>::readval(contents | |
1179 | + 2 * sizeof(uint32_t)); | |
908794a9 | 1180 | if (ncols == 0 || nused == 0) |
77429909 CC |
1181 | return; |
1182 | ||
1183 | unsigned int nslots = | |
1184 | elfcpp::Swap_unaligned<32, big_endian>::readval(contents | |
1185 | + 3 * sizeof(uint32_t)); | |
1186 | ||
1187 | const unsigned char* phash = contents + 4 * sizeof(uint32_t); | |
1188 | const unsigned char* pindex = phash + nslots * sizeof(uint64_t); | |
908794a9 CC |
1189 | const unsigned char* pcolhdrs = pindex + nslots * sizeof(uint32_t); |
1190 | const unsigned char* poffsets = pcolhdrs + ncols * sizeof(uint32_t); | |
1191 | const unsigned char* psizes = poffsets + nused * ncols * sizeof(uint32_t); | |
1192 | const unsigned char* pend = psizes + nused * ncols * sizeof(uint32_t); | |
1193 | ||
1194 | if (pend > contents + index_len) | |
1195 | gold_fatal(_("%s: section %s is corrupt"), this->name_, | |
1196 | this->section_name(shndx).c_str()); | |
1197 | ||
1198 | // Copy the related sections and track the section offsets and sizes. | |
1199 | Section_bounds sections[elfcpp::DW_SECT_MAX + 1]; | |
1200 | for (int i = elfcpp::DW_SECT_ABBREV; i <= elfcpp::DW_SECT_MAX; ++i) | |
1201 | { | |
1202 | if (debug_shndx[i] > 0) | |
1203 | sections[i] = this->copy_section(output_file, debug_shndx[i], | |
1204 | static_cast<elfcpp::DW_SECT>(i)); | |
1205 | } | |
77429909 | 1206 | |
908794a9 CC |
1207 | // Get the contents of the .debug_info.dwo or .debug_types.dwo section. |
1208 | section_size_type info_len; | |
1209 | bool info_is_new; | |
1210 | const unsigned char* info_contents = | |
1211 | this->section_contents(info_shndx, &info_len, &info_is_new); | |
77429909 CC |
1212 | |
1213 | // Loop over the slots of the hash table. | |
1214 | for (unsigned int i = 0; i < nslots; ++i) | |
1215 | { | |
908794a9 | 1216 | uint64_t signature = |
77429909 | 1217 | elfcpp::Swap_unaligned<64, big_endian>::readval(phash); |
908794a9 CC |
1218 | unsigned int index = |
1219 | elfcpp::Swap_unaligned<32, big_endian>::readval(pindex); | |
1220 | if (index != 0 && (!is_tu_index || !output_file->lookup_tu(signature))) | |
77429909 | 1221 | { |
908794a9 CC |
1222 | Unit_set* unit_set = new Unit_set(); |
1223 | unit_set->signature = signature; | |
1224 | const unsigned char* pch = pcolhdrs; | |
1225 | const unsigned char* porow = | |
1226 | poffsets + (index - 1) * ncols * sizeof(uint32_t); | |
1227 | const unsigned char* psrow = | |
1228 | psizes + (index - 1) * ncols * sizeof(uint32_t); | |
1229 | ||
1230 | // Adjust the offset of each contribution within the input section | |
1231 | // by the offset of the input section within the output section. | |
1232 | for (unsigned int j = 0; j <= ncols; j++) | |
77429909 | 1233 | { |
908794a9 CC |
1234 | unsigned int dw_sect = |
1235 | elfcpp::Swap_unaligned<64, big_endian>::readval(pch); | |
1236 | unsigned int offset = | |
1237 | elfcpp::Swap_unaligned<64, big_endian>::readval(porow); | |
1238 | unsigned int size = | |
1239 | elfcpp::Swap_unaligned<64, big_endian>::readval(psrow); | |
1240 | unit_set->sections[dw_sect].offset = (sections[dw_sect].offset | |
1241 | + offset); | |
1242 | unit_set->sections[dw_sect].size = size; | |
1243 | pch += sizeof(uint32_t); | |
1244 | porow += sizeof(uint32_t); | |
1245 | psrow += sizeof(uint32_t); | |
77429909 | 1246 | } |
77429909 | 1247 | |
908794a9 CC |
1248 | const unsigned char* unit_start = |
1249 | info_contents + unit_set->sections[info_sect].offset; | |
1250 | section_size_type unit_length = unit_set->sections[info_sect].size; | |
77429909 | 1251 | |
908794a9 CC |
1252 | // Dwp_output_file::add_contribution writes the .debug_info.dwo |
1253 | // section directly to the output file, so we only need to | |
1254 | // duplicate contributions for .debug_types.dwo section. | |
1255 | if (is_tu_index) | |
77429909 | 1256 | { |
908794a9 CC |
1257 | unsigned char *copy = new unsigned char[unit_length]; |
1258 | memcpy(copy, unit_start, unit_length); | |
1259 | unit_start = copy; | |
77429909 | 1260 | } |
908794a9 CC |
1261 | section_offset_type off = |
1262 | output_file->add_contribution(info_sect, unit_start, | |
1263 | unit_length, 1); | |
1264 | unit_set->sections[info_sect].offset = off; | |
1265 | if (is_tu_index) | |
1266 | output_file->add_tu_set(unit_set); | |
1267 | else | |
1268 | output_file->add_cu_set(unit_set); | |
77429909 CC |
1269 | } |
1270 | phash += sizeof(uint64_t); | |
1271 | pindex += sizeof(uint32_t); | |
1272 | } | |
1273 | ||
908794a9 | 1274 | if (index_is_new) |
77429909 | 1275 | delete[] contents; |
908794a9 CC |
1276 | if (info_is_new) |
1277 | delete[] info_contents; | |
77429909 CC |
1278 | } |
1279 | ||
94e49e16 CC |
1280 | // Verify the .debug_cu_index section of a .dwp file, comparing it |
1281 | // against the list of .dwo files referenced by the corresponding | |
1282 | // executable file. | |
1283 | ||
1284 | bool | |
1285 | Dwo_file::verify_dwo_list(unsigned int shndx, const File_list& files) | |
1286 | { | |
1287 | if (this->obj_->is_big_endian()) | |
1288 | return this->sized_verify_dwo_list<true>(shndx, files); | |
1289 | else | |
1290 | return this->sized_verify_dwo_list<false>(shndx, files); | |
1291 | } | |
1292 | ||
1293 | template <bool big_endian> | |
1294 | bool | |
1295 | Dwo_file::sized_verify_dwo_list(unsigned int shndx, const File_list& files) | |
1296 | { | |
1297 | gold_assert(shndx > 0); | |
1298 | ||
1299 | section_size_type index_len; | |
1300 | bool index_is_new; | |
1301 | const unsigned char* contents = | |
1302 | this->section_contents(shndx, &index_len, &index_is_new); | |
1303 | ||
1304 | unsigned int version = | |
1305 | elfcpp::Swap_unaligned<32, big_endian>::readval(contents); | |
1306 | ||
1307 | // We don't support version 1 anymore because it was experimental | |
1308 | // and because in normal use, dwp is not expected to read .dwp files | |
1309 | // produced by an earlier version of the tool. | |
1310 | if (version != 2) | |
1311 | gold_fatal(_("%s: section %s has unsupported version number %d"), | |
1312 | this->name_, this->section_name(shndx).c_str(), version); | |
1313 | ||
1314 | unsigned int ncols = | |
1315 | elfcpp::Swap_unaligned<32, big_endian>::readval(contents | |
1316 | + sizeof(uint32_t)); | |
1317 | unsigned int nused = | |
1318 | elfcpp::Swap_unaligned<32, big_endian>::readval(contents | |
1319 | + 2 * sizeof(uint32_t)); | |
1320 | if (ncols == 0 || nused == 0) | |
1321 | return true; | |
1322 | ||
1323 | unsigned int nslots = | |
1324 | elfcpp::Swap_unaligned<32, big_endian>::readval(contents | |
1325 | + 3 * sizeof(uint32_t)); | |
1326 | ||
1327 | const unsigned char* phash = contents + 4 * sizeof(uint32_t); | |
1328 | const unsigned char* pindex = phash + nslots * sizeof(uint64_t); | |
1329 | const unsigned char* pcolhdrs = pindex + nslots * sizeof(uint32_t); | |
1330 | const unsigned char* poffsets = pcolhdrs + ncols * sizeof(uint32_t); | |
1331 | const unsigned char* psizes = poffsets + nused * ncols * sizeof(uint32_t); | |
1332 | const unsigned char* pend = psizes + nused * ncols * sizeof(uint32_t); | |
1333 | ||
1334 | if (pend > contents + index_len) | |
1335 | gold_fatal(_("%s: section %s is corrupt"), this->name_, | |
1336 | this->section_name(shndx).c_str()); | |
1337 | ||
1338 | int nmissing = 0; | |
1339 | for (File_list::const_iterator f = files.begin(); f != files.end(); ++f) | |
1340 | { | |
1341 | uint64_t dwo_id = f->dwo_id; | |
1342 | unsigned int slot = static_cast<unsigned int>(dwo_id) & (nslots - 1); | |
1343 | const unsigned char* ph = phash + slot * sizeof(uint64_t); | |
1344 | const unsigned char* pi = pindex + slot * sizeof(uint32_t); | |
1345 | uint64_t probe = elfcpp::Swap_unaligned<64, big_endian>::readval(ph); | |
1346 | uint32_t row_index = elfcpp::Swap_unaligned<32, big_endian>::readval(pi); | |
1347 | if (row_index != 0 && probe != dwo_id) | |
1348 | { | |
1349 | unsigned int h2 = ((static_cast<unsigned int>(dwo_id >> 32) | |
1350 | & (nslots - 1)) | 1); | |
1351 | do | |
1352 | { | |
1353 | slot = (slot + h2) & (nslots - 1); | |
1354 | ph = phash + slot * sizeof(uint64_t); | |
1355 | pi = pindex + slot * sizeof(uint32_t); | |
1356 | probe = elfcpp::Swap_unaligned<64, big_endian>::readval(ph); | |
1357 | row_index = elfcpp::Swap_unaligned<32, big_endian>::readval(pi); | |
1358 | } while (row_index != 0 && probe != dwo_id); | |
1359 | } | |
1360 | if (row_index == 0) | |
1361 | { | |
1362 | printf(_("missing .dwo file: %016llx %s\n"), | |
1363 | static_cast<long long>(dwo_id), f->dwo_name.c_str()); | |
1364 | ++nmissing; | |
1365 | } | |
1366 | } | |
1367 | ||
1368 | gold_info(_("Found %d missing .dwo files"), nmissing); | |
1369 | ||
1370 | if (index_is_new) | |
1371 | delete[] contents; | |
1372 | ||
1373 | return nmissing == 0; | |
1374 | } | |
1375 | ||
77429909 CC |
1376 | // Merge the input string table section into the output file. |
1377 | ||
1378 | void | |
1379 | Dwo_file::add_strings(Dwp_output_file* output_file, unsigned int debug_str) | |
1380 | { | |
1381 | section_size_type len; | |
1382 | bool is_new; | |
1383 | const unsigned char* pdata = this->section_contents(debug_str, &len, &is_new); | |
1384 | const char* p = reinterpret_cast<const char*>(pdata); | |
1385 | const char* pend = p + len; | |
1386 | ||
1387 | // Check that the last string is null terminated. | |
1388 | if (pend[-1] != '\0') | |
1389 | gold_fatal(_("%s: last entry in string section '%s' " | |
1390 | "is not null terminated"), | |
1391 | this->name_, | |
1392 | this->section_name(debug_str).c_str()); | |
1393 | ||
1394 | // Count the number of strings in the section, and size the map. | |
1395 | size_t count = 0; | |
1396 | for (const char* pt = p; pt < pend; pt += strlen(pt) + 1) | |
1397 | ++count; | |
1398 | this->str_offset_map_.reserve(count + 1); | |
1399 | ||
1400 | // Add the strings to the output string table, and record the new offsets | |
1401 | // in the map. | |
1402 | section_offset_type i = 0; | |
1403 | section_offset_type new_offset; | |
1404 | while (p < pend) | |
1405 | { | |
1406 | size_t len = strlen(p); | |
1407 | new_offset = output_file->add_string(p, len); | |
1408 | this->str_offset_map_.push_back(std::make_pair(i, new_offset)); | |
1409 | p += len + 1; | |
1410 | i += len + 1; | |
1411 | } | |
1412 | new_offset = 0; | |
1413 | this->str_offset_map_.push_back(std::make_pair(i, new_offset)); | |
1414 | if (is_new) | |
1415 | delete[] pdata; | |
1416 | } | |
1417 | ||
1418 | // Copy a section from the input file to the output file. | |
908794a9 CC |
1419 | // Return the offset and length of this input section's contribution |
1420 | // in the output section. If copying .debug_str_offsets.dwo, remap | |
1421 | // the string offsets for the output string table. | |
77429909 | 1422 | |
908794a9 | 1423 | Section_bounds |
77429909 | 1424 | Dwo_file::copy_section(Dwp_output_file* output_file, unsigned int shndx, |
908794a9 | 1425 | elfcpp::DW_SECT section_id) |
77429909 CC |
1426 | { |
1427 | // Some sections may be referenced from more than one set. | |
1428 | // Don't copy a section more than once. | |
908794a9 CC |
1429 | if (this->sect_offsets_[shndx].size > 0) |
1430 | return this->sect_offsets_[shndx]; | |
77429909 | 1431 | |
908794a9 CC |
1432 | // Get the section contents. Upon return, if IS_NEW is true, the memory |
1433 | // has been allocated via new; if false, the memory is part of the mapped | |
1434 | // input file, and we will need to duplicate it so that it will persist | |
1435 | // after we close the input file. | |
77429909 CC |
1436 | section_size_type len; |
1437 | bool is_new; | |
1438 | const unsigned char* contents = this->section_contents(shndx, &len, &is_new); | |
1439 | ||
908794a9 | 1440 | if (section_id == elfcpp::DW_SECT_STR_OFFSETS) |
77429909 CC |
1441 | { |
1442 | const unsigned char* remapped = this->remap_str_offsets(contents, len); | |
1443 | if (is_new) | |
1444 | delete[] contents; | |
1445 | contents = remapped; | |
908794a9 CC |
1446 | } |
1447 | else if (!is_new) | |
1448 | { | |
1449 | unsigned char* copy = new unsigned char[len]; | |
1450 | memcpy(copy, contents, len); | |
1451 | contents = copy; | |
77429909 CC |
1452 | } |
1453 | ||
908794a9 CC |
1454 | // Add the contents of the input section to the output section. |
1455 | // The output file takes ownership of the memory pointed to by CONTENTS. | |
1456 | section_offset_type off = output_file->add_contribution(section_id, contents, | |
1457 | len, 1); | |
d5834edb | 1458 | |
908794a9 CC |
1459 | // Store the output section bounds. |
1460 | Section_bounds bounds(off, len); | |
1461 | this->sect_offsets_[shndx] = bounds; | |
1462 | ||
1463 | return bounds; | |
77429909 CC |
1464 | } |
1465 | ||
1466 | // Remap the | |
1467 | const unsigned char* | |
1468 | Dwo_file::remap_str_offsets(const unsigned char* contents, | |
1469 | section_size_type len) | |
1470 | { | |
1471 | if ((len & 3) != 0) | |
1472 | gold_fatal(_("%s: .debug_str_offsets.dwo section size not a multiple of 4"), | |
1473 | this->name_); | |
1474 | ||
1475 | if (this->obj_->is_big_endian()) | |
1476 | return this->sized_remap_str_offsets<true>(contents, len); | |
1477 | else | |
1478 | return this->sized_remap_str_offsets<false>(contents, len); | |
1479 | } | |
1480 | ||
1481 | template <bool big_endian> | |
1482 | const unsigned char* | |
1483 | Dwo_file::sized_remap_str_offsets(const unsigned char* contents, | |
1484 | section_size_type len) | |
1485 | { | |
1486 | unsigned char* remapped = new unsigned char[len]; | |
1487 | const unsigned char* p = contents; | |
1488 | unsigned char* q = remapped; | |
1489 | while (len > 0) | |
1490 | { | |
1491 | unsigned int val = elfcpp::Swap_unaligned<32, big_endian>::readval(p); | |
1492 | val = this->remap_str_offset(val); | |
1493 | elfcpp::Swap_unaligned<32, big_endian>::writeval(q, val); | |
1494 | len -= 4; | |
1495 | p += 4; | |
1496 | q += 4; | |
1497 | } | |
1498 | return remapped; | |
1499 | } | |
1500 | ||
1501 | unsigned int | |
598c7410 | 1502 | Dwo_file::remap_str_offset(section_offset_type val) |
77429909 CC |
1503 | { |
1504 | Str_offset_map_entry entry; | |
1505 | entry.first = val; | |
1506 | ||
1507 | Str_offset_map::const_iterator p = | |
1508 | std::lower_bound(this->str_offset_map_.begin(), | |
1509 | this->str_offset_map_.end(), | |
1510 | entry, Offset_compare()); | |
1511 | ||
1512 | if (p == this->str_offset_map_.end() || p->first > val) | |
1513 | { | |
1514 | if (p == this->str_offset_map_.begin()) | |
1515 | return 0; | |
1516 | --p; | |
1517 | gold_assert(p->first <= val); | |
1518 | } | |
1519 | ||
1520 | return p->second + (val - p->first); | |
1521 | } | |
1522 | ||
908794a9 CC |
1523 | // Add a set of .debug_info.dwo or .debug_types.dwo and related sections |
1524 | // to OUTPUT_FILE. | |
77429909 CC |
1525 | |
1526 | void | |
908794a9 CC |
1527 | Dwo_file::add_unit_set(Dwp_output_file* output_file, unsigned int *debug_shndx, |
1528 | bool is_debug_types) | |
77429909 | 1529 | { |
908794a9 CC |
1530 | unsigned int shndx = (is_debug_types |
1531 | ? debug_shndx[elfcpp::DW_SECT_TYPES] | |
1532 | : debug_shndx[elfcpp::DW_SECT_INFO]); | |
77429909 | 1533 | |
908794a9 | 1534 | gold_assert(shndx != 0); |
77429909 | 1535 | |
908794a9 | 1536 | if (debug_shndx[elfcpp::DW_SECT_ABBREV] == 0) |
77429909 CC |
1537 | gold_fatal(_("%s: no .debug_abbrev.dwo section found"), this->name_); |
1538 | ||
908794a9 CC |
1539 | // Copy the related sections and track the section offsets and sizes. |
1540 | Section_bounds sections[elfcpp::DW_SECT_MAX + 1]; | |
1541 | for (int i = elfcpp::DW_SECT_ABBREV; i <= elfcpp::DW_SECT_MAX; ++i) | |
1542 | { | |
1543 | if (debug_shndx[i] > 0) | |
1544 | sections[i] = this->copy_section(output_file, debug_shndx[i], | |
1545 | static_cast<elfcpp::DW_SECT>(i)); | |
1546 | } | |
e44c3715 | 1547 | |
908794a9 CC |
1548 | // Parse the .debug_info or .debug_types section and add each compilation |
1549 | // or type unit to the output file, along with the contributions to the | |
1550 | // related sections. | |
1551 | Unit_reader reader(is_debug_types, this->obj_, shndx); | |
1552 | reader.add_units(output_file, debug_shndx[elfcpp::DW_SECT_ABBREV], sections); | |
77429909 CC |
1553 | } |
1554 | ||
1555 | // Class Dwp_output_file. | |
1556 | ||
1557 | // Record the target info from an input file. On first call, we | |
1558 | // set the ELF header values for the output file. On subsequent | |
1559 | // calls, we just verify that the values match. | |
1560 | ||
1561 | void | |
1562 | Dwp_output_file::record_target_info(const char*, int machine, | |
1563 | int size, bool big_endian, | |
1564 | int osabi, int abiversion) | |
1565 | { | |
1566 | // TODO: Check the values on subsequent calls. | |
1567 | if (this->size_ > 0) | |
1568 | return; | |
1569 | ||
1570 | this->machine_ = machine; | |
1571 | this->size_ = size; | |
1572 | this->big_endian_ = big_endian; | |
1573 | this->osabi_ = osabi; | |
1574 | this->abiversion_ = abiversion; | |
1575 | ||
1576 | if (size == 32) | |
1577 | this->next_file_offset_ = elfcpp::Elf_sizes<32>::ehdr_size; | |
1578 | else if (size == 64) | |
1579 | this->next_file_offset_ = elfcpp::Elf_sizes<64>::ehdr_size; | |
1580 | else | |
1581 | gold_unreachable(); | |
1582 | ||
1583 | this->fd_ = ::fopen(this->name_, "wb"); | |
1584 | if (this->fd_ == NULL) | |
1585 | gold_fatal(_("%s: %s"), this->name_, strerror(errno)); | |
1586 | ||
1587 | // Write zeroes for the ELF header initially. We'll write | |
1588 | // the actual header during finalize(). | |
1589 | static const char buf[elfcpp::Elf_sizes<64>::ehdr_size] = { 0 }; | |
d361fafb L |
1590 | if (::fwrite(buf, 1, this->next_file_offset_, this->fd_) |
1591 | < (size_t) this->next_file_offset_) | |
1592 | gold_fatal(_("%s: %s"), this->name_, strerror(errno)); | |
77429909 CC |
1593 | } |
1594 | ||
1595 | // Add a string to the debug strings section. | |
1596 | ||
1597 | section_offset_type | |
1598 | Dwp_output_file::add_string(const char* str, size_t len) | |
1599 | { | |
1600 | Stringpool::Key key; | |
1601 | this->stringpool_.add_with_length(str, len, true, &key); | |
1602 | this->have_strings_ = true; | |
1603 | // We aren't supposed to call get_offset() until after | |
1604 | // calling set_string_offsets(), but the offsets will | |
1605 | // not change unless optimizing the string pool. | |
1606 | return this->stringpool_.get_offset_from_key(key); | |
1607 | } | |
1608 | ||
1609 | // Align the file offset to the given boundary. | |
1610 | ||
1611 | static inline off_t | |
1612 | align_offset(off_t off, int align) | |
1613 | { | |
1614 | return (off + align - 1) & ~(align - 1); | |
1615 | } | |
1616 | ||
908794a9 | 1617 | // Add a new output section and return the section index. |
77429909 CC |
1618 | |
1619 | unsigned int | |
908794a9 | 1620 | Dwp_output_file::add_output_section(const char* section_name, int align) |
d5834edb | 1621 | { |
908794a9 CC |
1622 | Section sect(section_name, align); |
1623 | this->sections_.push_back(sect); | |
1624 | return this->shnum_++; | |
1625 | } | |
d5834edb | 1626 | |
908794a9 CC |
1627 | // Add a contribution to a section in the output file, and return the offset |
1628 | // of the contribution within the output section. The .debug_info.dwo section | |
1629 | // is expected to be the largest one, so we will write the contents of this | |
1630 | // section directly to the output file as we receive contributions, allowing | |
1631 | // us to free that memory as soon as possible. We will save the remaining | |
1632 | // contributions until we finalize the layout of the output file. | |
d5834edb | 1633 | |
908794a9 CC |
1634 | section_offset_type |
1635 | Dwp_output_file::add_contribution(elfcpp::DW_SECT section_id, | |
1636 | const unsigned char* contents, | |
1637 | section_size_type len, | |
1638 | int align) | |
1639 | { | |
1640 | const char* section_name = get_dwarf_section_name(section_id); | |
1641 | gold_assert(static_cast<size_t>(section_id) < this->section_id_map_.size()); | |
1642 | unsigned int shndx = this->section_id_map_[section_id]; | |
d5834edb | 1643 | |
908794a9 CC |
1644 | // Create the section if necessary. |
1645 | if (shndx == 0) | |
1646 | { | |
1647 | section_name = this->shstrtab_.add_with_length(section_name, | |
1648 | strlen(section_name), | |
1649 | false, NULL); | |
1650 | shndx = this->add_output_section(section_name, align); | |
1651 | this->section_id_map_[section_id] = shndx; | |
1652 | } | |
d5834edb | 1653 | |
908794a9 CC |
1654 | Section& section = this->sections_[shndx - 1]; |
1655 | ||
1656 | section_offset_type section_offset; | |
1657 | ||
1658 | if (section_id == elfcpp::DW_SECT_INFO) | |
1659 | { | |
1660 | // Write the .debug_info.dwo section directly. | |
1661 | // We do not need to free the memory in this case. | |
1662 | off_t file_offset = this->next_file_offset_; | |
1663 | gold_assert(this->size_ > 0 && file_offset > 0); | |
1664 | ||
1665 | file_offset = align_offset(file_offset, align); | |
1666 | if (section.offset == 0) | |
1667 | section.offset = file_offset; | |
1668 | ||
1669 | if (align > section.align) | |
1670 | { | |
1671 | // Since we've already committed to the layout for this | |
1672 | // section, an unexpected large alignment boundary may | |
1673 | // be impossible to honor. | |
1674 | if (align_offset(section.offset, align) != section.offset) | |
1675 | gold_fatal(_("%s: alignment (%d) for section '%s' " | |
1676 | "cannot be honored"), | |
1677 | this->name_, align, section_name); | |
1678 | section.align = align; | |
1679 | } | |
1680 | ||
1681 | section_offset = file_offset - section.offset; | |
1682 | section.size = file_offset + len - section.offset; | |
1683 | ||
1684 | ::fseek(this->fd_, file_offset, SEEK_SET); | |
1685 | if (::fwrite(contents, 1, len, this->fd_) < len) | |
1686 | gold_fatal(_("%s: error writing section '%s'"), this->name_, | |
1687 | section_name); | |
1688 | this->next_file_offset_ = file_offset + len; | |
1689 | } | |
1690 | else | |
1691 | { | |
1692 | // Collect the contributions and keep track of the total size. | |
1693 | if (align > section.align) | |
1694 | section.align = align; | |
1695 | section_offset = align_offset(section.size, align); | |
1696 | section.size = section_offset + len; | |
1697 | Contribution contrib = { section_offset, len, contents }; | |
1698 | section.contributions.push_back(contrib); | |
1699 | } | |
1700 | ||
1701 | return section_offset; | |
77429909 CC |
1702 | } |
1703 | ||
1704 | // Add a set of .debug_info and related sections to the output file. | |
1705 | ||
1706 | void | |
908794a9 | 1707 | Dwp_output_file::add_cu_set(Unit_set* cu_set) |
77429909 | 1708 | { |
908794a9 | 1709 | uint64_t dwo_id = cu_set->signature; |
77429909 | 1710 | unsigned int slot; |
2a77e2ab CC |
1711 | if (!this->cu_index_.find_or_add(dwo_id, &slot)) |
1712 | this->cu_index_.enter_set(slot, cu_set); | |
1713 | else | |
1714 | gold_warning(_("%s: duplicate entry for CU (dwo_id 0x%llx)"), | |
1715 | this->name_, (unsigned long long)dwo_id); | |
77429909 CC |
1716 | } |
1717 | ||
1718 | // Lookup a type signature and return TRUE if we have already seen it. | |
1719 | bool | |
1720 | Dwp_output_file::lookup_tu(uint64_t type_sig) | |
1721 | { | |
1722 | this->last_type_sig_ = type_sig; | |
1723 | return this->tu_index_.find_or_add(type_sig, &this->last_tu_slot_); | |
1724 | } | |
1725 | ||
1726 | // Add a set of .debug_types and related sections to the output file. | |
1727 | ||
1728 | void | |
908794a9 | 1729 | Dwp_output_file::add_tu_set(Unit_set* tu_set) |
77429909 | 1730 | { |
908794a9 | 1731 | uint64_t type_sig = tu_set->signature; |
77429909 CC |
1732 | unsigned int slot; |
1733 | if (type_sig == this->last_type_sig_) | |
1734 | slot = this->last_tu_slot_; | |
1735 | else | |
1736 | this->tu_index_.find_or_add(type_sig, &slot); | |
1737 | this->tu_index_.enter_set(slot, tu_set); | |
1738 | } | |
1739 | ||
1740 | // Find a slot in the hash table for SIGNATURE. Return TRUE | |
1741 | // if the entry already exists. | |
1742 | ||
1743 | bool | |
1744 | Dwp_output_file::Dwp_index::find_or_add(uint64_t signature, | |
1745 | unsigned int* slotp) | |
1746 | { | |
1747 | if (this->capacity_ == 0) | |
1748 | this->initialize(); | |
1749 | unsigned int slot = | |
1750 | static_cast<unsigned int>(signature) & (this->capacity_ - 1); | |
1751 | unsigned int secondary_hash; | |
1752 | uint64_t probe = this->hash_table_[slot]; | |
908794a9 CC |
1753 | uint32_t row_index = this->index_table_[slot]; |
1754 | if (row_index != 0 && probe != signature) | |
77429909 CC |
1755 | { |
1756 | secondary_hash = (static_cast<unsigned int>(signature >> 32) | |
1757 | & (this->capacity_ - 1)) | 1; | |
1758 | do | |
1759 | { | |
1760 | slot = (slot + secondary_hash) & (this->capacity_ - 1); | |
1761 | probe = this->hash_table_[slot]; | |
908794a9 CC |
1762 | row_index = this->index_table_[slot]; |
1763 | } while (row_index != 0 && probe != signature); | |
77429909 CC |
1764 | } |
1765 | *slotp = slot; | |
908794a9 | 1766 | return (row_index != 0); |
77429909 CC |
1767 | } |
1768 | ||
1769 | // Enter a CU or TU set at the given SLOT in the hash table. | |
1770 | ||
1771 | void | |
1772 | Dwp_output_file::Dwp_index::enter_set(unsigned int slot, | |
908794a9 | 1773 | const Unit_set* set) |
77429909 CC |
1774 | { |
1775 | gold_assert(slot < this->capacity_); | |
908794a9 CC |
1776 | |
1777 | // Add a row to the offsets and sizes tables. | |
1778 | this->section_table_.push_back(set); | |
1779 | uint32_t row_index = this->section_table_rows(); | |
1780 | ||
1781 | // Mark the sections used in this set. | |
1782 | for (unsigned int i = 1; i <= elfcpp::DW_SECT_MAX; i++) | |
1783 | if (set->sections[i].size > 0) | |
1784 | this->section_mask_ |= 1 << i; | |
77429909 CC |
1785 | |
1786 | // Enter the signature and pool index into the hash table. | |
2a77e2ab | 1787 | gold_assert(this->hash_table_[slot] == 0); |
908794a9 CC |
1788 | this->hash_table_[slot] = set->signature; |
1789 | this->index_table_[slot] = row_index; | |
77429909 CC |
1790 | ++this->used_; |
1791 | ||
1792 | // Grow the hash table when we exceed 2/3 capacity. | |
1793 | if (this->used_ * 3 > this->capacity_ * 2) | |
1794 | this->grow(); | |
1795 | } | |
1796 | ||
1797 | // Initialize the hash table. | |
1798 | ||
1799 | void | |
1800 | Dwp_output_file::Dwp_index::initialize() | |
1801 | { | |
1802 | this->capacity_ = 16; | |
1803 | this->hash_table_ = new uint64_t[this->capacity_]; | |
1804 | memset(this->hash_table_, 0, this->capacity_ * sizeof(uint64_t)); | |
1805 | this->index_table_ = new uint32_t[this->capacity_]; | |
1806 | memset(this->index_table_, 0, this->capacity_ * sizeof(uint32_t)); | |
1807 | } | |
1808 | ||
1809 | // Grow the hash table when we reach 2/3 capacity. | |
1810 | ||
1811 | void | |
1812 | Dwp_output_file::Dwp_index::grow() | |
1813 | { | |
1814 | unsigned int old_capacity = this->capacity_; | |
1815 | uint64_t* old_hash_table = this->hash_table_; | |
1816 | uint32_t* old_index_table = this->index_table_; | |
1817 | unsigned int old_used = this->used_; | |
1818 | ||
1819 | this->capacity_ = old_capacity * 2; | |
1820 | this->hash_table_ = new uint64_t[this->capacity_]; | |
1821 | memset(this->hash_table_, 0, this->capacity_ * sizeof(uint64_t)); | |
1822 | this->index_table_ = new uint32_t[this->capacity_]; | |
1823 | memset(this->index_table_, 0, this->capacity_ * sizeof(uint32_t)); | |
1824 | this->used_ = 0; | |
1825 | ||
1826 | for (unsigned int i = 0; i < old_capacity; ++i) | |
1827 | { | |
1828 | uint64_t signature = old_hash_table[i]; | |
908794a9 CC |
1829 | uint32_t row_index = old_index_table[i]; |
1830 | if (row_index != 0) | |
77429909 CC |
1831 | { |
1832 | unsigned int slot; | |
1833 | bool found = this->find_or_add(signature, &slot); | |
1834 | gold_assert(!found); | |
1835 | this->hash_table_[slot] = signature; | |
908794a9 | 1836 | this->index_table_[slot] = row_index; |
77429909 CC |
1837 | ++this->used_; |
1838 | } | |
1839 | } | |
1840 | gold_assert(this->used_ == old_used); | |
1841 | ||
1842 | delete[] old_hash_table; | |
1843 | delete[] old_index_table; | |
1844 | } | |
1845 | ||
77429909 CC |
1846 | // Finalize the file, write the string tables and index sections, |
1847 | // and close the file. | |
1848 | ||
1849 | void | |
1850 | Dwp_output_file::finalize() | |
1851 | { | |
1852 | unsigned char* buf; | |
1853 | ||
908794a9 CC |
1854 | // Write the accumulated output sections. |
1855 | for (unsigned int i = 0; i < this->sections_.size(); i++) | |
1856 | { | |
1857 | Section& sect = this->sections_[i]; | |
1858 | // If the offset has already been assigned, the section has been written. | |
1859 | if (sect.offset > 0 || sect.size == 0) | |
1860 | continue; | |
1861 | off_t file_offset = this->next_file_offset_; | |
1862 | file_offset = align_offset(file_offset, sect.align); | |
1863 | sect.offset = file_offset; | |
1864 | this->write_contributions(sect); | |
1865 | this->next_file_offset_ = file_offset + sect.size; | |
1866 | } | |
1867 | ||
77429909 CC |
1868 | // Write the debug string table. |
1869 | if (this->have_strings_) | |
1870 | { | |
1871 | this->stringpool_.set_string_offsets(); | |
1872 | section_size_type len = this->stringpool_.get_strtab_size(); | |
1873 | buf = new unsigned char[len]; | |
1874 | this->stringpool_.write_to_buffer(buf, len); | |
908794a9 | 1875 | this->write_new_section(".debug_str.dwo", buf, len, 1); |
77429909 CC |
1876 | delete[] buf; |
1877 | } | |
1878 | ||
1879 | // Write the CU and TU indexes. | |
1880 | if (this->big_endian_) | |
1881 | { | |
1882 | this->write_index<true>(".debug_cu_index", this->cu_index_); | |
1883 | this->write_index<true>(".debug_tu_index", this->tu_index_); | |
1884 | } | |
1885 | else | |
1886 | { | |
1887 | this->write_index<false>(".debug_cu_index", this->cu_index_); | |
1888 | this->write_index<false>(".debug_tu_index", this->tu_index_); | |
1889 | } | |
1890 | ||
1891 | off_t file_offset = this->next_file_offset_; | |
1892 | ||
1893 | // Write the section string table. | |
1894 | this->shstrndx_ = this->shnum_++; | |
1895 | const char* shstrtab_name = | |
908794a9 CC |
1896 | this->shstrtab_.add_with_length(".shstrtab", sizeof(".shstrtab") - 1, |
1897 | false, NULL); | |
77429909 CC |
1898 | this->shstrtab_.set_string_offsets(); |
1899 | section_size_type shstrtab_len = this->shstrtab_.get_strtab_size(); | |
1900 | buf = new unsigned char[shstrtab_len]; | |
1901 | this->shstrtab_.write_to_buffer(buf, shstrtab_len); | |
1902 | off_t shstrtab_off = file_offset; | |
1903 | ::fseek(this->fd_, file_offset, 0); | |
1904 | if (::fwrite(buf, 1, shstrtab_len, this->fd_) < shstrtab_len) | |
1905 | gold_fatal(_("%s: error writing section '.shstrtab'"), this->name_); | |
1906 | delete[] buf; | |
1907 | file_offset += shstrtab_len; | |
1908 | ||
1909 | // Write the section header table. The first entry is a NULL entry. | |
1910 | // This is followed by the debug sections, and finally we write the | |
1911 | // .shstrtab section header. | |
1912 | file_offset = align_offset(file_offset, this->size_ == 32 ? 4 : 8); | |
1913 | this->shoff_ = file_offset; | |
1914 | ::fseek(this->fd_, file_offset, 0); | |
1915 | section_size_type sh0_size = 0; | |
1916 | unsigned int sh0_link = 0; | |
1917 | if (this->shnum_ >= elfcpp::SHN_LORESERVE) | |
1918 | sh0_size = this->shnum_; | |
1919 | if (this->shstrndx_ >= elfcpp::SHN_LORESERVE) | |
1920 | sh0_link = this->shstrndx_; | |
1921 | this->write_shdr(NULL, 0, 0, 0, 0, sh0_size, sh0_link, 0, 0, 0); | |
1922 | for (unsigned int i = 0; i < this->sections_.size(); ++i) | |
1923 | { | |
1924 | Section& sect = this->sections_[i]; | |
1925 | this->write_shdr(sect.name, elfcpp::SHT_PROGBITS, 0, 0, sect.offset, | |
1926 | sect.size, 0, 0, sect.align, 0); | |
1927 | } | |
1928 | this->write_shdr(shstrtab_name, elfcpp::SHT_STRTAB, 0, 0, | |
1929 | shstrtab_off, shstrtab_len, 0, 0, 1, 0); | |
1930 | ||
1931 | // Write the ELF header. | |
1932 | this->write_ehdr(); | |
1933 | ||
1934 | // Close the file. | |
1935 | if (this->fd_ != NULL) | |
1936 | { | |
1937 | if (::fclose(this->fd_) != 0) | |
1938 | gold_fatal(_("%s: %s"), this->name_, strerror(errno)); | |
1939 | } | |
1940 | this->fd_ = NULL; | |
1941 | } | |
1942 | ||
908794a9 CC |
1943 | // Write the contributions to an output section. |
1944 | ||
1945 | void | |
1946 | Dwp_output_file::write_contributions(const Section& sect) | |
1947 | { | |
1948 | for (unsigned int i = 0; i < sect.contributions.size(); ++i) | |
1949 | { | |
1950 | const Contribution& c = sect.contributions[i]; | |
1951 | ::fseek(this->fd_, sect.offset + c.output_offset, SEEK_SET); | |
1952 | if (::fwrite(c.contents, 1, c.size, this->fd_) < c.size) | |
1953 | gold_fatal(_("%s: error writing section '%s'"), this->name_, sect.name); | |
1954 | delete[] c.contents; | |
1955 | } | |
1956 | } | |
1957 | ||
1958 | // Write a new section to the output file. | |
1959 | ||
1960 | void | |
1961 | Dwp_output_file::write_new_section(const char* section_name, | |
1962 | const unsigned char* contents, | |
1963 | section_size_type len, int align) | |
1964 | { | |
1965 | section_name = this->shstrtab_.add_with_length(section_name, | |
1966 | strlen(section_name), | |
1967 | false, NULL); | |
1968 | unsigned int shndx = this->add_output_section(section_name, align); | |
1969 | Section& section = this->sections_[shndx - 1]; | |
1970 | off_t file_offset = this->next_file_offset_; | |
1971 | file_offset = align_offset(file_offset, align); | |
1972 | section.offset = file_offset; | |
1973 | section.size = len; | |
1974 | ::fseek(this->fd_, file_offset, SEEK_SET); | |
1975 | if (::fwrite(contents, 1, len, this->fd_) < len) | |
1976 | gold_fatal(_("%s: error writing section '%s'"), this->name_, section_name); | |
1977 | this->next_file_offset_ = file_offset + len; | |
1978 | } | |
1979 | ||
77429909 | 1980 | // Write a CU or TU index section. |
908794a9 | 1981 | |
77429909 CC |
1982 | template<bool big_endian> |
1983 | void | |
1984 | Dwp_output_file::write_index(const char* sect_name, const Dwp_index& index) | |
1985 | { | |
1986 | const unsigned int nslots = index.hash_table_total_slots(); | |
1987 | const unsigned int nused = index.hash_table_used_slots(); | |
908794a9 CC |
1988 | const unsigned int nrows = index.section_table_rows(); |
1989 | ||
1990 | int column_mask = index.section_table_cols(); | |
1991 | unsigned int ncols = 0; | |
1992 | for (unsigned int c = 1; c <= elfcpp::DW_SECT_MAX; ++c) | |
1993 | if (column_mask & (1 << c)) | |
1994 | ncols++; | |
1995 | const unsigned int ntable = (nrows * 2 + 1) * ncols; | |
1996 | ||
77429909 CC |
1997 | const section_size_type index_size = (4 * sizeof(uint32_t) |
1998 | + nslots * sizeof(uint64_t) | |
1999 | + nslots * sizeof(uint32_t) | |
908794a9 | 2000 | + ntable * sizeof(uint32_t)); |
77429909 CC |
2001 | |
2002 | // Allocate a buffer for the section contents. | |
2003 | unsigned char* buf = new unsigned char[index_size]; | |
2004 | unsigned char* p = buf; | |
2005 | ||
2006 | // Write the section header: version number, padding, | |
2007 | // number of used slots and total number of slots. | |
908794a9 | 2008 | elfcpp::Swap_unaligned<32, big_endian>::writeval(p, 2); |
77429909 | 2009 | p += sizeof(uint32_t); |
908794a9 | 2010 | elfcpp::Swap_unaligned<32, big_endian>::writeval(p, ncols); |
77429909 CC |
2011 | p += sizeof(uint32_t); |
2012 | elfcpp::Swap_unaligned<32, big_endian>::writeval(p, nused); | |
2013 | p += sizeof(uint32_t); | |
2014 | elfcpp::Swap_unaligned<32, big_endian>::writeval(p, nslots); | |
2015 | p += sizeof(uint32_t); | |
2016 | ||
2017 | // Write the hash table. | |
2018 | for (unsigned int i = 0; i < nslots; ++i) | |
2019 | { | |
2020 | elfcpp::Swap_unaligned<64, big_endian>::writeval(p, index.hash_table(i)); | |
2021 | p += sizeof(uint64_t); | |
2022 | } | |
2023 | ||
2024 | // Write the parallel index table. | |
2025 | for (unsigned int i = 0; i < nslots; ++i) | |
2026 | { | |
2027 | elfcpp::Swap_unaligned<32, big_endian>::writeval(p, index.index_table(i)); | |
2028 | p += sizeof(uint32_t); | |
2029 | } | |
2030 | ||
908794a9 CC |
2031 | // Write the first row of the table of section offsets. |
2032 | for (unsigned int c = 1; c <= elfcpp::DW_SECT_MAX; ++c) | |
d5834edb | 2033 | { |
908794a9 CC |
2034 | if (column_mask & (1 << c)) |
2035 | { | |
2036 | elfcpp::Swap_unaligned<32, big_endian>::writeval(p, c); | |
2037 | p += sizeof(uint32_t); | |
2038 | } | |
2039 | } | |
2040 | ||
2041 | // Write the table of section offsets. | |
2042 | Dwp_index::Section_table::const_iterator tbl = index.section_table(); | |
2043 | for (unsigned int r = 0; r < nrows; ++r) | |
2044 | { | |
2045 | gold_assert(tbl != index.section_table_end()); | |
2046 | const Section_bounds* sects = (*tbl)->sections; | |
2047 | for (unsigned int c = 1; c <= elfcpp::DW_SECT_MAX; ++c) | |
2048 | { | |
2049 | if (column_mask & (1 << c)) | |
2050 | { | |
2051 | section_offset_type offset = sects[c].offset; | |
2052 | elfcpp::Swap_unaligned<32, big_endian>::writeval(p, offset); | |
2053 | p += sizeof(uint32_t); | |
2054 | } | |
2055 | else | |
2056 | gold_assert(sects[c].size == 0); | |
2057 | } | |
2058 | ++tbl; | |
2059 | } | |
2060 | ||
2061 | // Write the table of section sizes. | |
2062 | tbl = index.section_table(); | |
2063 | for (unsigned int r = 0; r < nrows; ++r) | |
2064 | { | |
2065 | gold_assert(tbl != index.section_table_end()); | |
2066 | const Section_bounds* sects = (*tbl)->sections; | |
2067 | for (unsigned int c = 1; c <= elfcpp::DW_SECT_MAX; ++c) | |
2068 | { | |
2069 | if (column_mask & (1 << c)) | |
2070 | { | |
2071 | section_size_type size = sects[c].size; | |
2072 | elfcpp::Swap_unaligned<32, big_endian>::writeval(p, size); | |
2073 | p += sizeof(uint32_t); | |
2074 | } | |
2075 | else | |
2076 | gold_assert(sects[c].size == 0); | |
2077 | } | |
2078 | ++tbl; | |
77429909 CC |
2079 | } |
2080 | ||
2081 | gold_assert(p == buf + index_size); | |
2082 | ||
908794a9 | 2083 | this->write_new_section(sect_name, buf, index_size, sizeof(uint64_t)); |
77429909 CC |
2084 | |
2085 | delete[] buf; | |
2086 | } | |
2087 | ||
2088 | // Write the ELF header. | |
2089 | ||
2090 | void | |
2091 | Dwp_output_file::write_ehdr() | |
2092 | { | |
2093 | if (this->size_ == 32) | |
2094 | { | |
2095 | if (this->big_endian_) | |
2096 | return this->sized_write_ehdr<32, true>(); | |
2097 | else | |
2098 | return this->sized_write_ehdr<32, false>(); | |
2099 | } | |
2100 | else if (this->size_ == 64) | |
2101 | { | |
2102 | if (this->big_endian_) | |
2103 | return this->sized_write_ehdr<64, true>(); | |
2104 | else | |
2105 | return this->sized_write_ehdr<64, false>(); | |
2106 | } | |
2107 | else | |
2108 | gold_unreachable(); | |
2109 | } | |
2110 | ||
2111 | template<unsigned int size, bool big_endian> | |
2112 | void | |
2113 | Dwp_output_file::sized_write_ehdr() | |
2114 | { | |
2115 | const unsigned int ehdr_size = elfcpp::Elf_sizes<size>::ehdr_size; | |
2116 | unsigned char buf[ehdr_size]; | |
2117 | elfcpp::Ehdr_write<size, big_endian> ehdr(buf); | |
2118 | ||
2119 | unsigned char e_ident[elfcpp::EI_NIDENT]; | |
2120 | memset(e_ident, 0, elfcpp::EI_NIDENT); | |
2121 | e_ident[elfcpp::EI_MAG0] = elfcpp::ELFMAG0; | |
2122 | e_ident[elfcpp::EI_MAG1] = elfcpp::ELFMAG1; | |
2123 | e_ident[elfcpp::EI_MAG2] = elfcpp::ELFMAG2; | |
2124 | e_ident[elfcpp::EI_MAG3] = elfcpp::ELFMAG3; | |
2125 | if (size == 32) | |
2126 | e_ident[elfcpp::EI_CLASS] = elfcpp::ELFCLASS32; | |
2127 | else if (size == 64) | |
2128 | e_ident[elfcpp::EI_CLASS] = elfcpp::ELFCLASS64; | |
2129 | else | |
2130 | gold_unreachable(); | |
2131 | e_ident[elfcpp::EI_DATA] = (big_endian | |
2132 | ? elfcpp::ELFDATA2MSB | |
2133 | : elfcpp::ELFDATA2LSB); | |
2134 | e_ident[elfcpp::EI_VERSION] = elfcpp::EV_CURRENT; | |
2135 | ehdr.put_e_ident(e_ident); | |
2136 | ||
2137 | ehdr.put_e_type(elfcpp::ET_REL); | |
2138 | ehdr.put_e_machine(this->machine_); | |
2139 | ehdr.put_e_version(elfcpp::EV_CURRENT); | |
2140 | ehdr.put_e_entry(0); | |
2141 | ehdr.put_e_phoff(0); | |
2142 | ehdr.put_e_shoff(this->shoff_); | |
2143 | ehdr.put_e_flags(0); | |
2144 | ehdr.put_e_ehsize(elfcpp::Elf_sizes<size>::ehdr_size); | |
2145 | ehdr.put_e_phentsize(0); | |
2146 | ehdr.put_e_phnum(0); | |
2147 | ehdr.put_e_shentsize(elfcpp::Elf_sizes<size>::shdr_size); | |
2148 | ehdr.put_e_shnum(this->shnum_ < elfcpp::SHN_LORESERVE ? this->shnum_ : 0); | |
2149 | ehdr.put_e_shstrndx(this->shstrndx_ < elfcpp::SHN_LORESERVE | |
2150 | ? this->shstrndx_ | |
2151 | : static_cast<unsigned int>(elfcpp::SHN_XINDEX)); | |
2152 | ||
2153 | ::fseek(this->fd_, 0, 0); | |
2154 | if (::fwrite(buf, 1, ehdr_size, this->fd_) < ehdr_size) | |
2155 | gold_fatal(_("%s: error writing ELF header"), this->name_); | |
2156 | } | |
2157 | ||
2158 | // Write a section header. | |
2159 | ||
2160 | void | |
2161 | Dwp_output_file::write_shdr(const char* name, unsigned int type, | |
2162 | unsigned int flags, uint64_t addr, off_t offset, | |
2163 | section_size_type sect_size, unsigned int link, | |
2164 | unsigned int info, unsigned int align, | |
2165 | unsigned int ent_size) | |
2166 | { | |
2167 | if (this->size_ == 32) | |
2168 | { | |
2169 | if (this->big_endian_) | |
2170 | return this->sized_write_shdr<32, true>(name, type, flags, addr, | |
2171 | offset, sect_size, link, info, | |
2172 | align, ent_size); | |
2173 | else | |
2174 | return this->sized_write_shdr<32, false>(name, type, flags, addr, | |
2175 | offset, sect_size, link, info, | |
2176 | align, ent_size); | |
2177 | } | |
2178 | else if (this->size_ == 64) | |
2179 | { | |
2180 | if (this->big_endian_) | |
2181 | return this->sized_write_shdr<64, true>(name, type, flags, addr, | |
2182 | offset, sect_size, link, info, | |
2183 | align, ent_size); | |
2184 | else | |
2185 | return this->sized_write_shdr<64, false>(name, type, flags, addr, | |
2186 | offset, sect_size, link, info, | |
2187 | align, ent_size); | |
2188 | } | |
2189 | else | |
2190 | gold_unreachable(); | |
2191 | } | |
2192 | ||
2193 | template<unsigned int size, bool big_endian> | |
2194 | void | |
2195 | Dwp_output_file::sized_write_shdr(const char* name, unsigned int type, | |
2196 | unsigned int flags, uint64_t addr, | |
2197 | off_t offset, section_size_type sect_size, | |
2198 | unsigned int link, unsigned int info, | |
2199 | unsigned int align, unsigned int ent_size) | |
2200 | { | |
2201 | const unsigned int shdr_size = elfcpp::Elf_sizes<size>::shdr_size; | |
2202 | unsigned char buf[shdr_size]; | |
2203 | elfcpp::Shdr_write<size, big_endian> shdr(buf); | |
2204 | ||
2205 | shdr.put_sh_name(name == NULL ? 0 : this->shstrtab_.get_offset(name)); | |
2206 | shdr.put_sh_type(type); | |
2207 | shdr.put_sh_flags(flags); | |
2208 | shdr.put_sh_addr(addr); | |
2209 | shdr.put_sh_offset(offset); | |
2210 | shdr.put_sh_size(sect_size); | |
2211 | shdr.put_sh_link(link); | |
2212 | shdr.put_sh_info(info); | |
2213 | shdr.put_sh_addralign(align); | |
2214 | shdr.put_sh_entsize(ent_size); | |
2215 | if (::fwrite(buf, 1, shdr_size, this->fd_) < shdr_size) | |
2216 | gold_fatal(_("%s: error writing section header table"), this->name_); | |
2217 | } | |
2218 | ||
29bd8b6b CC |
2219 | // Class Dwo_name_info_reader. |
2220 | ||
2221 | // Visit a compilation unit. | |
2222 | ||
2223 | void | |
2224 | Dwo_name_info_reader::visit_compilation_unit(off_t, off_t, Dwarf_die* die) | |
2225 | { | |
2226 | const char* dwo_name = die->string_attribute(elfcpp::DW_AT_GNU_dwo_name); | |
2227 | if (dwo_name != NULL) | |
94e49e16 CC |
2228 | { |
2229 | uint64_t dwo_id = die->uint_attribute(elfcpp::DW_AT_GNU_dwo_id); | |
2230 | this->files_->push_back(Dwo_file_entry(dwo_id, dwo_name)); | |
2231 | } | |
29bd8b6b CC |
2232 | } |
2233 | ||
908794a9 CC |
2234 | // Class Unit_reader. |
2235 | ||
2236 | // Read the CUs or TUs and add them to the output file. | |
2237 | ||
2238 | void | |
2239 | Unit_reader::add_units(Dwp_output_file* output_file, | |
2240 | unsigned int debug_abbrev, | |
2241 | Section_bounds* sections) | |
2242 | { | |
2243 | this->output_file_ = output_file; | |
2244 | this->sections_ = sections; | |
2245 | this->set_abbrev_shndx(debug_abbrev); | |
2246 | this->parse(); | |
2247 | } | |
77429909 CC |
2248 | |
2249 | // Visit a compilation unit. | |
2250 | ||
2251 | void | |
908794a9 | 2252 | Unit_reader::visit_compilation_unit(off_t, off_t cu_length, Dwarf_die* die) |
77429909 | 2253 | { |
908794a9 CC |
2254 | if (cu_length == 0) |
2255 | return; | |
2256 | ||
2257 | Unit_set* unit_set = new Unit_set(); | |
2258 | unit_set->signature = die->uint_attribute(elfcpp::DW_AT_GNU_dwo_id); | |
2259 | for (unsigned int i = elfcpp::DW_SECT_ABBREV; i <= elfcpp::DW_SECT_MAX; ++i) | |
2260 | unit_set->sections[i] = this->sections_[i]; | |
2261 | ||
2262 | // Dwp_output_file::add_contribution writes the .debug_info.dwo section | |
2263 | // directly to the output file, so we do not need to duplicate the | |
2264 | // section contents, and add_contribution does not need to free the memory. | |
2265 | section_offset_type off = | |
2266 | this->output_file_->add_contribution(elfcpp::DW_SECT_INFO, | |
2267 | this->buffer_at_offset(0), | |
2268 | cu_length, 1); | |
2269 | Section_bounds bounds(off, cu_length); | |
2270 | unit_set->sections[elfcpp::DW_SECT_INFO] = bounds; | |
2271 | this->output_file_->add_cu_set(unit_set); | |
77429909 CC |
2272 | } |
2273 | ||
2274 | // Visit a type unit. | |
2275 | ||
2276 | void | |
908794a9 CC |
2277 | Unit_reader::visit_type_unit(off_t, off_t tu_length, off_t, |
2278 | uint64_t signature, Dwarf_die*) | |
77429909 | 2279 | { |
908794a9 CC |
2280 | if (tu_length == 0) |
2281 | return; | |
2282 | if (this->output_file_->lookup_tu(signature)) | |
2283 | return; | |
2284 | ||
2285 | Unit_set* unit_set = new Unit_set(); | |
2286 | unit_set->signature = signature; | |
2287 | for (unsigned int i = elfcpp::DW_SECT_ABBREV; i <= elfcpp::DW_SECT_MAX; ++i) | |
2288 | unit_set->sections[i] = this->sections_[i]; | |
2289 | ||
2290 | unsigned char* contents = new unsigned char[tu_length]; | |
2291 | memcpy(contents, this->buffer_at_offset(0), tu_length); | |
2292 | section_offset_type off = | |
2293 | this->output_file_->add_contribution(elfcpp::DW_SECT_TYPES, contents, | |
2294 | tu_length, 1); | |
2295 | Section_bounds bounds(off, tu_length); | |
2296 | unit_set->sections[elfcpp::DW_SECT_TYPES] = bounds; | |
2297 | this->output_file_->add_tu_set(unit_set); | |
77429909 CC |
2298 | } |
2299 | ||
2300 | }; // End namespace gold | |
2301 | ||
2302 | using namespace gold; | |
2303 | ||
2304 | // Options. | |
2305 | ||
94e49e16 CC |
2306 | enum Dwp_options { |
2307 | VERIFY_ONLY = 0x101, | |
2308 | }; | |
2309 | ||
77429909 CC |
2310 | struct option dwp_options[] = |
2311 | { | |
29bd8b6b | 2312 | { "exec", required_argument, NULL, 'e' }, |
c1a8d56e | 2313 | { "help", no_argument, NULL, 'h' }, |
77429909 | 2314 | { "output", required_argument, NULL, 'o' }, |
c1a8d56e | 2315 | { "verbose", no_argument, NULL, 'v' }, |
94e49e16 | 2316 | { "verify-only", no_argument, NULL, VERIFY_ONLY }, |
c1a8d56e | 2317 | { "version", no_argument, NULL, 'V' }, |
77429909 CC |
2318 | { NULL, 0, NULL, 0 } |
2319 | }; | |
2320 | ||
2321 | // Print usage message and exit. | |
2322 | ||
2323 | static void | |
c1a8d56e | 2324 | usage(FILE* fd, int exit_status) |
77429909 | 2325 | { |
29bd8b6b | 2326 | fprintf(fd, _("Usage: %s [options] [file...]\n"), program_name); |
c1a8d56e | 2327 | fprintf(fd, _(" -h, --help Print this help message\n")); |
29bd8b6b | 2328 | fprintf(fd, _(" -e EXE, --exec EXE Get list of dwo files from EXE" |
94e49e16 | 2329 | " (defaults output to EXE.dwp)\n")); |
29bd8b6b | 2330 | fprintf(fd, _(" -o FILE, --output FILE Set output dwp file name\n")); |
c1a8d56e | 2331 | fprintf(fd, _(" -v, --verbose Verbose output\n")); |
94e49e16 CC |
2332 | fprintf(fd, _(" --verify-only Verify output file against" |
2333 | " exec file\n")); | |
c1a8d56e CC |
2334 | fprintf(fd, _(" -V, --version Print version number\n")); |
2335 | ||
2336 | // REPORT_BUGS_TO is defined in bfd/bfdver.h. | |
2337 | const char* report = REPORT_BUGS_TO; | |
2338 | if (*report != '\0') | |
2339 | fprintf(fd, _("\nReport bugs to %s\n"), report); | |
2340 | exit(exit_status); | |
2341 | } | |
2342 | ||
2343 | // Report version information. | |
2344 | ||
2345 | static void | |
2346 | print_version() | |
2347 | { | |
2348 | // This output is intended to follow the GNU standards. | |
2349 | printf("GNU dwp %s\n", BFD_VERSION_STRING); | |
4b95cf5c | 2350 | printf(_("Copyright (C) 2014 Free Software Foundation, Inc.\n")); |
c1a8d56e CC |
2351 | printf(_("\ |
2352 | This program is free software; you may redistribute it under the terms of\n\ | |
2353 | the GNU General Public License version 3 or (at your option) any later version.\n\ | |
2354 | This program has absolutely no warranty.\n")); | |
2355 | exit(EXIT_SUCCESS); | |
77429909 CC |
2356 | } |
2357 | ||
2358 | // Main program. | |
2359 | ||
2360 | int | |
2361 | main(int argc, char** argv) | |
2362 | { | |
2363 | #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES) | |
2364 | setlocale(LC_MESSAGES, ""); | |
2365 | #endif | |
2366 | #if defined (HAVE_SETLOCALE) | |
2367 | setlocale(LC_CTYPE, ""); | |
2368 | #endif | |
2369 | bindtextdomain(PACKAGE, LOCALEDIR); | |
2370 | textdomain(PACKAGE); | |
2371 | ||
2372 | program_name = argv[0]; | |
2373 | ||
2374 | // Initialize the global parameters, to let random code get to the | |
2375 | // errors object. | |
2376 | Errors errors(program_name); | |
2377 | set_parameters_errors(&errors); | |
2378 | ||
2379 | // Initialize gold's global options. We don't use these in | |
2380 | // this program, but they need to be initialized so that | |
2381 | // functions we call from libgold work properly. | |
2382 | General_options options; | |
2383 | set_parameters_options(&options); | |
2384 | ||
2385 | // In libiberty; expands @filename to the args in "filename". | |
2386 | expandargv(&argc, &argv); | |
2387 | ||
2388 | // Collect file names and options. | |
77429909 | 2389 | File_list files; |
29bd8b6b CC |
2390 | std::string output_filename; |
2391 | const char* exe_filename = NULL; | |
77429909 | 2392 | bool verbose = false; |
94e49e16 | 2393 | bool verify_only = false; |
77429909 | 2394 | int c; |
29bd8b6b | 2395 | while ((c = getopt_long(argc, argv, "e:ho:vV", dwp_options, NULL)) != -1) |
77429909 CC |
2396 | { |
2397 | switch (c) | |
2398 | { | |
c1a8d56e CC |
2399 | case 'h': |
2400 | usage(stdout, EXIT_SUCCESS); | |
29bd8b6b CC |
2401 | case 'e': |
2402 | exe_filename = optarg; | |
2403 | break; | |
77429909 | 2404 | case 'o': |
29bd8b6b | 2405 | output_filename.assign(optarg); |
77429909 | 2406 | break; |
c1a8d56e CC |
2407 | case 'v': |
2408 | verbose = true; | |
2409 | break; | |
94e49e16 CC |
2410 | case VERIFY_ONLY: |
2411 | verify_only = true; | |
2412 | break; | |
c1a8d56e CC |
2413 | case 'V': |
2414 | print_version(); | |
77429909 CC |
2415 | case '?': |
2416 | default: | |
c1a8d56e | 2417 | usage(stderr, EXIT_FAILURE); |
77429909 CC |
2418 | } |
2419 | } | |
29bd8b6b CC |
2420 | |
2421 | if (output_filename.empty()) | |
2422 | { | |
2423 | if (exe_filename == NULL) | |
2424 | gold_fatal(_("no output file specified")); | |
2425 | output_filename.assign(exe_filename); | |
2426 | output_filename.append(".dwp"); | |
2427 | } | |
2428 | ||
29bd8b6b CC |
2429 | // Get list of .dwo files from the executable. |
2430 | if (exe_filename != NULL) | |
2431 | { | |
2432 | Dwo_file exe_file(exe_filename); | |
2433 | exe_file.read_executable(&files); | |
2434 | } | |
2435 | ||
2436 | // Add any additional files listed on command line. | |
77429909 | 2437 | for (int i = optind; i < argc; ++i) |
94e49e16 | 2438 | files.push_back(Dwo_file_entry(0, argv[i])); |
77429909 | 2439 | |
29bd8b6b CC |
2440 | if (exe_filename == NULL && files.empty()) |
2441 | gold_fatal(_("no input files and no executable specified")); | |
77429909 | 2442 | |
94e49e16 CC |
2443 | if (verify_only) |
2444 | { | |
2445 | // Get list of DWO files in the DWP file and compare with | |
2446 | // references found in the EXE file. | |
2447 | Dwo_file dwp_file(output_filename.c_str()); | |
2448 | bool ok = dwp_file.verify(files); | |
2449 | return ok ? EXIT_SUCCESS : EXIT_FAILURE; | |
2450 | } | |
2451 | ||
77429909 | 2452 | // Process each file, adding its contents to the output file. |
94e49e16 | 2453 | Dwp_output_file output_file(output_filename.c_str()); |
77429909 CC |
2454 | for (File_list::const_iterator f = files.begin(); f != files.end(); ++f) |
2455 | { | |
2456 | if (verbose) | |
94e49e16 CC |
2457 | fprintf(stderr, "%s\n", f->dwo_name.c_str()); |
2458 | Dwo_file dwo_file(f->dwo_name.c_str()); | |
77429909 CC |
2459 | dwo_file.read(&output_file); |
2460 | } | |
77429909 CC |
2461 | output_file.finalize(); |
2462 | ||
2463 | return EXIT_SUCCESS; | |
2464 | } |