1 // incremental.cc -- incremental linking test/debug tool
2
3 // Copyright (C) 2009-2024 Free Software Foundation, Inc.
4 // Written by Rafael Avila de Espindola <rafael.espindola@gmail.com>
5
6 // This file is part of gold.
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
24 // This file is a (still incomplete) test/debug tool that should display
25 // all information available in the incremental linking sections in a
26 // format that is easy to read.
27 // Once the format is a bit more stable, this should probably be moved to
28 // readelf. Because of that, the use of gold's data structures and functions
29 // is just a short term convenience and not a design decision.
30
31 #include "gold.h"
32
33 #include <stdio.h>
34 #include <errno.h>
35 #include <time.h>
36
37 #include "incremental.h"
38
39 namespace gold
40 {
41 class Output_file;
42 }
43
44 using namespace gold;
45
46 template<int size, bool big_endian>
47 static typename Incremental_inputs_reader<size, big_endian>::
48 Incremental_input_entry_reader
find_input_containing_global(Incremental_inputs_reader<size,big_endian> & incremental_inputs,unsigned int offset,unsigned int * symndx)49 find_input_containing_global(
50 Incremental_inputs_reader<size, big_endian>& incremental_inputs,
51 unsigned int offset,
52 unsigned int* symndx)
53 {
54 typedef Incremental_inputs_reader<size, big_endian> Inputs_reader;
55 static const unsigned int global_sym_entry_size =
56 Incremental_inputs_reader<size, big_endian>::global_sym_entry_size;
57
58 for (unsigned int i = 0; i < incremental_inputs.input_file_count(); ++i)
59 {
60 typename Inputs_reader::Incremental_input_entry_reader input_file =
61 incremental_inputs.input_file(i);
62 if (input_file.type() != INCREMENTAL_INPUT_OBJECT
63 && input_file.type() != INCREMENTAL_INPUT_ARCHIVE_MEMBER)
64 continue;
65 unsigned int nsyms = input_file.get_global_symbol_count();
66 if (offset >= input_file.get_symbol_offset(0)
67 && offset < input_file.get_symbol_offset(nsyms))
68 {
69 *symndx = ((offset - input_file.get_symbol_offset(0))
70 / global_sym_entry_size);
71 return input_file;
72 }
73 }
74 gold_unreachable();
75 }
76
77 template<int size, bool big_endian>
78 static void
dump_incremental_inputs(const char * argv0,const char * filename,Sized_incremental_binary<size,big_endian> * inc)79 dump_incremental_inputs(const char* argv0, const char* filename,
80 Sized_incremental_binary<size, big_endian>* inc)
81 {
82 typedef Incremental_binary::Location Location;
83 typedef Incremental_binary::View View;
84 typedef Incremental_inputs_reader<size, big_endian> Inputs_reader;
85 typedef typename Inputs_reader::Incremental_input_entry_reader Entry_reader;
86
87 if (!inc->has_incremental_info())
88 {
89 fprintf(stderr, "%s: %s: no .gnu_incremental_inputs section\n", argv0,
90 filename);
91 exit(1);
92 }
93
94 // Create a reader object for the .gnu_incremental_inputs section.
95
96 Incremental_inputs_reader<size, big_endian>
97 incremental_inputs(inc->inputs_reader());
98
99 if (incremental_inputs.version() != 2)
100 {
101 fprintf(stderr, "%s: %s: unknown incremental version %d\n", argv0,
102 filename, incremental_inputs.version());
103 exit(1);
104 }
105
106 const char* command_line = incremental_inputs.command_line();
107 if (command_line == NULL)
108 {
109 fprintf(stderr,
110 "%s: %s: failed to get link command line\n",
111 argv0, filename);
112 exit(1);
113 }
114 printf("Link command line: %s\n", command_line);
115
116 printf("\nInput files:\n");
117 for (unsigned int i = 0; i < incremental_inputs.input_file_count(); ++i)
118 {
119 Entry_reader input_file = incremental_inputs.input_file(i);
120
121 const char* objname = input_file.filename();
122 if (objname == NULL)
123 {
124 fprintf(stderr,"%s: %s: failed to get file name for object %u\n",
125 argv0, filename, i);
126 exit(1);
127 }
128 printf("[%d] %s\n", i, objname);
129
130 Timespec mtime = input_file.get_mtime();
131 printf(" Timestamp: %llu.%09d %s",
132 static_cast<unsigned long long>(mtime.seconds),
133 mtime.nanoseconds,
134 ctime(&mtime.seconds));
135
136 printf(" Serial Number: %d\n", input_file.arg_serial());
137 printf(" In System Directory: %s\n",
138 input_file.is_in_system_directory() ? "true" : "false");
139
140 Incremental_input_type input_type = input_file.type();
141 printf(" Type: ");
142 switch (input_type)
143 {
144 case INCREMENTAL_INPUT_OBJECT:
145 case INCREMENTAL_INPUT_ARCHIVE_MEMBER:
146 printf("%s\n", (input_type == INCREMENTAL_INPUT_OBJECT
147 ? "Object" : "Archive member"));
148 printf(" Input section count: %d\n",
149 input_file.get_input_section_count());
150 printf(" Global symbol count: %d\n",
151 input_file.get_global_symbol_count());
152 printf(" Local symbol offset: %d\n",
153 input_file.get_local_symbol_offset());
154 printf(" Local symbol count: %d\n",
155 input_file.get_local_symbol_count());
156 printf(" First dynamic reloc: %d\n",
157 input_file.get_first_dyn_reloc());
158 printf(" Dynamic reloc count: %d\n",
159 input_file.get_dyn_reloc_count());
160 printf(" COMDAT group count: %d\n",
161 input_file.get_comdat_group_count());
162 break;
163 case INCREMENTAL_INPUT_ARCHIVE:
164 printf("Archive\n");
165 printf(" Member count: %d\n", input_file.get_member_count());
166 printf(" Unused symbol count: %d\n",
167 input_file.get_unused_symbol_count());
168 break;
169 case INCREMENTAL_INPUT_SHARED_LIBRARY:
170 printf("Shared library\n");
171 printf(" As needed: %s\n",
172 input_file.as_needed() ? "true" : "false");
173 printf(" soname: %s\n",
174 input_file.get_soname());
175 printf(" Symbol count: %d\n",
176 input_file.get_global_symbol_count());
177 break;
178 case INCREMENTAL_INPUT_SCRIPT:
179 printf("Linker script\n");
180 printf(" Object count: %d\n", input_file.get_object_count());
181 break;
182 default:
183 fprintf(stderr, "%s: invalid file type for object %u: %d\n",
184 argv0, i, input_type);
185 exit(1);
186 }
187 }
188
189 printf("\nInput sections:\n");
190 for (unsigned int i = 0; i < incremental_inputs.input_file_count(); ++i)
191 {
192 Entry_reader input_file(incremental_inputs.input_file(i));
193
194 if (input_file.type() != INCREMENTAL_INPUT_OBJECT
195 && input_file.type() != INCREMENTAL_INPUT_ARCHIVE_MEMBER)
196 continue;
197
198 const char* objname = input_file.filename();
199 if (objname == NULL)
200 {
201 fprintf(stderr,"%s: %s: failed to get file name for object %u\n",
202 argv0, filename, i);
203 exit(1);
204 }
205
206 printf("[%d] %s\n", i, objname);
207
208 printf(" %3s %6s %8s %8s %s\n",
209 "n", "outndx", "offset", "size", "name");
210 unsigned int nsections = input_file.get_input_section_count();
211 for (unsigned int shndx = 0; shndx < nsections; ++shndx)
212 {
213 typename Entry_reader::Input_section_info info(
214 input_file.get_input_section(shndx));
215 printf(" %3d %6d %8lld %8lld %s\n", shndx + 1,
216 info.output_shndx,
217 static_cast<long long>(info.sh_offset),
218 static_cast<long long>(info.sh_size),
219 info.name);
220 }
221
222 unsigned int ncomdat = input_file.get_comdat_group_count();
223 for (unsigned int i = 0; i < ncomdat; ++i)
224 printf(" Comdat group: %s\n",
225 input_file.get_comdat_group_signature(i));
226 }
227
228 // Get a view of the .symtab section.
229
230 elfcpp::Elf_file<size, big_endian, Incremental_binary> elf_file(inc);
231
232 unsigned int symtab_shndx = elf_file.find_section_by_type(elfcpp::SHT_SYMTAB);
233 if (symtab_shndx == elfcpp::SHN_UNDEF) // Not found.
234 {
235 fprintf(stderr, "%s: %s: no symbol table section\n", argv0, filename);
236 exit(1);
237 }
238 Location symtab_location(elf_file.section_contents(symtab_shndx));
239 View symtab_view(inc->view(symtab_location));
240
241 // Get a view of the .strtab section.
242
243 unsigned int strtab_shndx = elf_file.section_link(symtab_shndx);
244 if (strtab_shndx == elfcpp::SHN_UNDEF
245 || strtab_shndx > elf_file.shnum()
246 || elf_file.section_type(strtab_shndx) != elfcpp::SHT_STRTAB)
247 {
248 fprintf(stderr, "%s: %s: no string table section\n", argv0, filename);
249 exit(1);
250 }
251 Location strtab_location(elf_file.section_contents(strtab_shndx));
252 View strtab_view(inc->view(strtab_location));
253 elfcpp::Elf_strtab strtab(strtab_view.data(), strtab_location.data_size);
254
255 // The .gnu_incremental_symtab section contains entries that parallel
256 // the global symbols of the main symbol table. The sh_info field
257 // of the main symbol table's section header tells us how many global
258 // symbols there are, but that count does not include any global
259 // symbols that were forced local during the link. Therefore, we
260 // use the size of the .gnu_incremental_symtab section to deduce
261 // the number of global symbols + forced-local symbols there are
262 // in the symbol table.
263 Incremental_symtab_reader<big_endian> isymtab(inc->symtab_reader());
264 Incremental_relocs_reader<size, big_endian> irelocs(inc->relocs_reader());
265 unsigned int sym_size = elfcpp::Elf_sizes<size>::sym_size;
266 unsigned int nsyms = symtab_location.data_size / sym_size;
267 unsigned int nglobals = isymtab.symbol_count();
268 unsigned int first_global = nsyms - nglobals;
269 unsigned const char* sym_p;
270
271 printf("\nGlobal symbols per input file:\n");
272 for (unsigned int i = 0; i < incremental_inputs.input_file_count(); ++i)
273 {
274 Entry_reader input_file(incremental_inputs.input_file(i));
275
276 if (input_file.type() != INCREMENTAL_INPUT_OBJECT
277 && input_file.type() != INCREMENTAL_INPUT_ARCHIVE_MEMBER
278 && input_file.type() != INCREMENTAL_INPUT_SHARED_LIBRARY)
279 continue;
280
281 const char* objname = input_file.filename();
282 if (objname == NULL)
283 {
284 fprintf(stderr,"%s: %s: failed to get file name for object %u\n",
285 argv0, filename, i);
286 exit(1);
287 }
288
289 printf("[%d] %s\n", i, objname);
290
291 unsigned int nsyms = input_file.get_global_symbol_count();
292 if (nsyms > 0)
293 printf(" %6s %6s %8s %8s %8s %8s\n",
294 "outndx", "shndx", "offset", "chain", "#relocs", "rbase");
295 if (input_file.type() == INCREMENTAL_INPUT_SHARED_LIBRARY)
296 {
297 for (unsigned int symndx = 0; symndx < nsyms; ++symndx)
298 {
299 bool is_def;
300 bool is_copy;
301 unsigned int output_symndx =
302 input_file.get_output_symbol_index(symndx, &is_def, &is_copy);
303 sym_p = symtab_view.data() + output_symndx * sym_size;
304 elfcpp::Sym<size, big_endian> sym(sym_p);
305 const char* symname;
306 if (!strtab.get_c_string(sym.get_st_name(), &symname))
307 symname = "<unknown>";
308 printf(" %6d %6s %8s %8s %8s %8s %-5s %s\n",
309 output_symndx,
310 "", "", "", "", "",
311 is_copy ? "COPY" : (is_def ? "DEF" : "UNDEF"),
312 symname);
313 }
314 }
315 else
316 {
317 for (unsigned int symndx = 0; symndx < nsyms; ++symndx)
318 {
319 Incremental_global_symbol_reader<big_endian> info(
320 input_file.get_global_symbol_reader(symndx));
321 unsigned int output_symndx = info.output_symndx();
322 sym_p = symtab_view.data() + output_symndx * sym_size;
323 elfcpp::Sym<size, big_endian> sym(sym_p);
324 const char* symname;
325 if (!strtab.get_c_string(sym.get_st_name(), &symname))
326 symname = "<unknown>";
327 printf(" %6d %6d %8d %8d %8d %8d %-5s %s\n",
328 output_symndx,
329 info.shndx() == -1U ? -1 : info.shndx(),
330 input_file.get_symbol_offset(symndx),
331 info.next_offset(),
332 info.reloc_count(),
333 info.reloc_offset(),
334 (info.shndx() == -1U
335 ? "BASE"
336 : info.shndx() == 0 ? "UNDEF" : "DEF"),
337 symname);
338 }
339 }
340 }
341
342 sym_p = symtab_view.data() + first_global * sym_size;
343 printf("\nGlobal symbol table:\n");
344 for (unsigned int i = 0; i < nglobals; i++)
345 {
346 elfcpp::Sym<size, big_endian> sym(sym_p);
347 const char* symname;
348 if (!strtab.get_c_string(sym.get_st_name(), &symname))
349 symname = "<unknown>";
350 printf("[%d] %s\n", first_global + i, symname);
351 unsigned int offset = isymtab.get_list_head(i);
352 while (offset > 0)
353 {
354 unsigned int sym_ndx;
355 Entry_reader input_file =
356 find_input_containing_global<size, big_endian>(incremental_inputs,
357 offset, &sym_ndx);
358 Incremental_global_symbol_reader<big_endian> sym_info(
359 input_file.get_global_symbol_reader(sym_ndx));
360 printf(" %s (first reloc: %d, reloc count: %d)",
361 input_file.filename(), sym_info.reloc_offset(),
362 sym_info.reloc_count());
363 if (sym_info.output_symndx() != first_global + i)
364 printf(" ** wrong output symndx (%d) **", sym_info.output_symndx());
365 printf("\n");
366 // Dump the relocations from this input file for this symbol.
367 unsigned int r_off = sym_info.reloc_offset();
368 for (unsigned int j = 0; j < sym_info.reloc_count(); j++)
369 {
370 printf(" %4d relocation type %3d shndx %2d"
371 " offset %016llx addend %016llx %s\n",
372 r_off,
373 irelocs.get_r_type(r_off),
374 irelocs.get_r_shndx(r_off),
375 static_cast<long long>(irelocs.get_r_offset(r_off)),
376 static_cast<long long>(irelocs.get_r_addend(r_off)),
377 symname);
378 r_off += irelocs.reloc_size;
379 }
380 offset = sym_info.next_offset();
381 }
382 sym_p += sym_size;
383 }
384
385 Incremental_got_plt_reader<big_endian> igot_plt(inc->got_plt_reader());
386 unsigned int ngot = igot_plt.get_got_entry_count();
387 unsigned int nplt = igot_plt.get_plt_entry_count();
388
389 printf("\nGOT entries:\n");
390 for (unsigned int i = 0; i < ngot; ++i)
391 {
392 unsigned int got_type = igot_plt.get_got_type(i);
393 unsigned int got_symndx = igot_plt.get_got_symndx(i);
394 unsigned int got_input_index = igot_plt.get_got_input_index(i);
395 printf("[%d] type %02x, ", i, got_type & 0x7f);
396 if ((got_type & 0x7f) == 0x7f)
397 printf("reserved");
398 else if (got_type & 0x80)
399 {
400 Entry_reader input_file =
401 incremental_inputs.input_file(got_input_index);
402 const char* objname = input_file.filename();
403 printf("local: %s (%d)", objname, got_symndx);
404 }
405 else
406 {
407 sym_p = symtab_view.data() + got_symndx * sym_size;
408 elfcpp::Sym<size, big_endian> sym(sym_p);
409 const char* symname;
410 if (!strtab.get_c_string(sym.get_st_name(), &symname))
411 symname = "<unknown>";
412 printf("global %s (%d)", symname, got_symndx);
413 }
414 printf("\n");
415 }
416
417 printf("\nPLT entries:\n");
418 for (unsigned int i = 0; i < nplt; ++i)
419 {
420 unsigned int plt_desc = igot_plt.get_plt_desc(i);
421 printf("[%d] ", i);
422 sym_p = symtab_view.data() + plt_desc * sym_size;
423 elfcpp::Sym<size, big_endian> sym(sym_p);
424 const char* symname;
425 if (!strtab.get_c_string(sym.get_st_name(), &symname))
426 symname = "<unknown>";
427 printf("%s (%d)\n", symname, plt_desc);
428 }
429
430 printf("\nUnused archive symbols:\n");
431 for (unsigned int i = 0; i < incremental_inputs.input_file_count(); ++i)
432 {
433 Entry_reader input_file(incremental_inputs.input_file(i));
434
435 if (input_file.type() != INCREMENTAL_INPUT_ARCHIVE)
436 continue;
437
438 const char* objname = input_file.filename();
439 if (objname == NULL)
440 {
441 fprintf(stderr,"%s: %s: failed to get file name for object %u\n",
442 argv0, filename, i);
443 exit(1);
444 }
445
446 printf("[%d] %s\n", i, objname);
447 unsigned int nsyms = input_file.get_unused_symbol_count();
448 for (unsigned int symndx = 0; symndx < nsyms; ++symndx)
449 printf(" %s\n", input_file.get_unused_symbol(symndx));
450 }
451
452 }
453
454 int
main(int argc,char ** argv)455 main(int argc, char** argv)
456 {
457 if (argc != 2)
458 {
459 fprintf(stderr, "Usage: %s <file>\n", argv[0]);
460 return 1;
461 }
462 const char* filename = argv[1];
463
464 Output_file* file = new Output_file(filename);
465
466 bool t = file->open_base_file(NULL, false);
467 if (!t)
468 {
469 fprintf(stderr, "%s: open_base_file(%s): %s\n", argv[0], filename,
470 strerror(errno));
471 return 1;
472 }
473
474 Incremental_binary* inc = open_incremental_binary(file);
475
476 if (inc == NULL)
477 {
478 fprintf(stderr, "%s: open_incremental_binary(%s): %s\n", argv[0],
479 filename, strerror(errno));
480 return 1;
481 }
482
483 switch (parameters->size_and_endianness())
484 {
485 #ifdef HAVE_TARGET_32_LITTLE
486 case Parameters::TARGET_32_LITTLE:
487 dump_incremental_inputs<32, false>(
488 argv[0], filename,
489 static_cast<Sized_incremental_binary<32, false>*>(inc));
490 break;
491 #endif
492 #ifdef HAVE_TARGET_32_BIG
493 case Parameters::TARGET_32_BIG:
494 dump_incremental_inputs<32, true>(
495 argv[0], filename,
496 static_cast<Sized_incremental_binary<32, true>*>(inc));
497 break;
498 #endif
499 #ifdef HAVE_TARGET_64_LITTLE
500 case Parameters::TARGET_64_LITTLE:
501 dump_incremental_inputs<64, false>(
502 argv[0], filename,
503 static_cast<Sized_incremental_binary<64, false>*>(inc));
504 break;
505 #endif
506 #ifdef HAVE_TARGET_64_BIG
507 case Parameters::TARGET_64_BIG:
508 dump_incremental_inputs<64, true>(
509 argv[0], filename,
510 static_cast<Sized_incremental_binary<64, true>*>(inc));
511 break;
512 #endif
513 default:
514 gold_unreachable();
515 }
516
517 return 0;
518 }
519