1 /* Discard section not used at runtime from object files.
2 Copyright (C) 2000-2012 Red Hat, Inc.
3 This file is part of elfutils.
4 Written by Ulrich Drepper <drepper@redhat.com>, 2000.
6 This file is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 elfutils is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
36 #include <stdio_ext.h>
40 #include <sys/param.h>
44 #include <elf-knowledge.h>
48 typedef uint8_t GElf_Byte;
50 /* Name and version of program. */
51 static void print_version (FILE *stream, struct argp_state *state);
52 ARGP_PROGRAM_VERSION_HOOK_DEF = print_version;
54 /* Bug report address. */
55 ARGP_PROGRAM_BUG_ADDRESS_DEF = PACKAGE_BUGREPORT;
58 /* Values for the parameters which have no short form. */
59 #define OPT_REMOVE_COMMENT 0x100
60 #define OPT_PERMISSIVE 0x101
61 #define OPT_STRIP_SECTIONS 0x102
62 #define OPT_RELOC_DEBUG 0x103
65 /* Definitions of arguments for argp functions. */
66 static const struct argp_option options[] =
68 { NULL, 0, NULL, 0, N_("Output selection:"), 0 },
69 { "output", 'o', "FILE", 0, N_("Place stripped output into FILE"), 0 },
70 { NULL, 'f', "FILE", 0, N_("Extract the removed sections into FILE"), 0 },
71 { NULL, 'F', "FILE", 0, N_("Embed name FILE instead of -f argument"), 0 },
73 { NULL, 0, NULL, 0, N_("Output options:"), 0 },
74 { "strip-all", 's', NULL, OPTION_HIDDEN, NULL, 0 },
75 { "strip-debug", 'g', NULL, 0, N_("Remove all debugging symbols"), 0 },
76 { NULL, 'd', NULL, OPTION_ALIAS, NULL, 0 },
77 { NULL, 'S', NULL, OPTION_ALIAS, NULL, 0 },
78 { "strip-sections", OPT_STRIP_SECTIONS, NULL, 0,
79 N_("Remove section headers (not recommended)"), 0 },
80 { "preserve-dates", 'p', NULL, 0,
81 N_("Copy modified/access timestamps to the output"), 0 },
82 { "reloc-debug-sections", OPT_RELOC_DEBUG, NULL, 0,
83 N_("Resolve all trivial relocations between debug sections if the removed sections are placed in a debug file (only relevant for ET_REL files, operation is not reversable, needs -f)"), 0 },
84 { "remove-comment", OPT_REMOVE_COMMENT, NULL, 0,
85 N_("Remove .comment section"), 0 },
86 { "remove-section", 'R', "SECTION", OPTION_HIDDEN, NULL, 0 },
87 { "permissive", OPT_PERMISSIVE, NULL, 0,
88 N_("Relax a few rules to handle slightly broken ELF files"), 0 },
89 { NULL, 0, NULL, 0, NULL, 0 }
92 /* Short description of program. */
93 static const char doc[] = N_("Discard symbols from object files.");
95 /* Strings for arguments in help texts. */
96 static const char args_doc[] = N_("[FILE...]");
98 /* Prototype for option handler. */
99 static error_t parse_opt (int key, char *arg, struct argp_state *state);
101 /* Data structure to communicate with argp functions. */
102 static struct argp argp =
104 options, parse_opt, args_doc, doc, NULL, NULL, NULL
108 /* Print symbols in file named FNAME. */
109 static int process_file (const char *fname);
111 /* Handle one ELF file. */
112 static int handle_elf (int fd, Elf *elf, const char *prefix,
113 const char *fname, mode_t mode, struct timeval tvp[2]);
115 /* Handle all files contained in the archive. */
116 static int handle_ar (int fd, Elf *elf, const char *prefix, const char *fname,
117 struct timeval tvp[2]);
119 #define INTERNAL_ERROR(fname) \
120 error (EXIT_FAILURE, 0, gettext ("%s: INTERNAL ERROR %d (%s-%s): %s"), \
121 fname, __LINE__, PACKAGE_VERSION, __DATE__, elf_errmsg (-1))
124 /* Name of the output file. */
125 static const char *output_fname;
127 /* Name of the debug output file. */
128 static const char *debug_fname;
130 /* Name to pretend the debug output file has. */
131 static const char *debug_fname_embed;
133 /* If true output files shall have same date as the input file. */
134 static bool preserve_dates;
136 /* If true .comment sections will be removed. */
137 static bool remove_comment;
139 /* If true remove all debug sections. */
140 static bool remove_debug;
142 /* If true remove all section headers. */
143 static bool remove_shdrs;
145 /* If true relax some ELF rules for input files. */
146 static bool permissive;
148 /* If true perform relocations between debug sections. */
149 static bool reloc_debug;
153 main (int argc, char *argv[])
158 /* Make memory leak detection possible. */
161 /* We use no threads here which can interfere with handling a stream. */
162 __fsetlocking (stdin, FSETLOCKING_BYCALLER);
163 __fsetlocking (stdout, FSETLOCKING_BYCALLER);
164 __fsetlocking (stderr, FSETLOCKING_BYCALLER);
167 setlocale (LC_ALL, "");
169 /* Make sure the message catalog can be found. */
170 bindtextdomain (PACKAGE_TARNAME, LOCALEDIR);
172 /* Initialize the message catalog. */
173 textdomain (PACKAGE_TARNAME);
175 /* Parse and process arguments. */
176 if (argp_parse (&argp, argc, argv, 0, &remaining, NULL) != 0)
179 if (reloc_debug && debug_fname == NULL)
180 error (EXIT_FAILURE, 0,
181 gettext ("--reloc-debug-sections used without -f"));
183 /* Tell the library which version we are expecting. */
184 elf_version (EV_CURRENT);
186 if (remaining == argc)
187 /* The user didn't specify a name so we use a.out. */
188 result = process_file ("a.out");
191 /* If we have seen the '-o' or '-f' option there must be exactly one
193 if ((output_fname != NULL || debug_fname != NULL)
194 && remaining + 1 < argc)
195 error (EXIT_FAILURE, 0, gettext ("\
196 Only one input file allowed together with '-o' and '-f'"));
198 /* Process all the remaining files. */
200 result |= process_file (argv[remaining]);
201 while (++remaining < argc);
208 /* Print the version information. */
210 print_version (FILE *stream, struct argp_state *state __attribute__ ((unused)))
212 fprintf (stream, "strip (%s) %s\n", PACKAGE_NAME, PACKAGE_VERSION);
213 fprintf (stream, gettext ("\
214 Copyright (C) %s Red Hat, Inc.\n\
215 This is free software; see the source for copying conditions. There is NO\n\
216 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
218 fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
222 /* Handle program arguments. */
224 parse_opt (int key, char *arg, struct argp_state *state)
229 if (debug_fname != NULL)
231 error (0, 0, gettext ("-f option specified twice"));
238 if (debug_fname_embed != NULL)
240 error (0, 0, gettext ("-F option specified twice"));
243 debug_fname_embed = arg;
247 if (output_fname != NULL)
249 error (0, 0, gettext ("-o option specified twice"));
256 preserve_dates = true;
259 case OPT_RELOC_DEBUG:
263 case OPT_REMOVE_COMMENT:
264 remove_comment = true;
268 if (!strcmp (arg, ".comment"))
269 remove_comment = true;
273 gettext ("-R option supports only .comment section"));
284 case OPT_STRIP_SECTIONS:
292 case 's': /* Ignored for compatibility. */
296 return ARGP_ERR_UNKNOWN;
303 process_file (const char *fname)
305 /* If we have to preserve the modify and access timestamps get them
306 now. We cannot use fstat() after opening the file since the open
307 would change the access time. */
308 struct stat64 pre_st;
309 struct timeval tv[2];
313 if (stat64 (fname, &pre_st) != 0)
315 error (0, errno, gettext ("cannot stat input file '%s'"), fname);
319 /* If we have to preserve the timestamp, we need it in the
320 format utimes() understands. */
321 TIMESPEC_TO_TIMEVAL (&tv[0], &pre_st.st_atim);
322 TIMESPEC_TO_TIMEVAL (&tv[1], &pre_st.st_mtim);
326 int fd = open (fname, output_fname == NULL ? O_RDWR : O_RDONLY);
329 error (0, errno, gettext ("while opening '%s'"), fname);
333 /* We always use fstat() even if we called stat() before. This is
334 done to make sure the information returned by stat() is for the
337 if (fstat64 (fd, &st) != 0)
339 error (0, errno, gettext ("cannot stat input file '%s'"), fname);
342 /* Paranoid mode on. */
344 && (st.st_ino != pre_st.st_ino || st.st_dev != pre_st.st_dev))
346 /* We detected a race. Try again. */
351 /* Now get the ELF descriptor. */
352 Elf *elf = elf_begin (fd, output_fname == NULL ? ELF_C_RDWR : ELF_C_READ,
355 switch (elf_kind (elf))
358 result = handle_elf (fd, elf, NULL, fname, st.st_mode & ACCESSPERMS,
359 preserve_dates ? tv : NULL);
363 /* It is not possible to strip the content of an archive direct
364 the output to a specific file. */
365 if (unlikely (output_fname != NULL || debug_fname != NULL))
367 error (0, 0, gettext ("%s: cannot use -o or -f when stripping archive"),
372 result = handle_ar (fd, elf, NULL, fname, preserve_dates ? tv : NULL);
376 error (0, 0, gettext ("%s: File format not recognized"), fname);
381 if (unlikely (elf_end (elf) != 0))
382 INTERNAL_ERROR (fname);
390 /* Maximum size of array allocated on stack. */
391 #define MAX_STACK_ALLOC (400 * 1024)
394 handle_elf (int fd, Elf *elf, const char *prefix, const char *fname,
395 mode_t mode, struct timeval tvp[2])
397 size_t prefix_len = prefix == NULL ? 0 : strlen (prefix);
398 size_t fname_len = strlen (fname) + 1;
399 char *fullname = alloca (prefix_len + 1 + fname_len);
401 Elf *debugelf = NULL;
402 char *tmp_debug_fname = NULL;
411 Elf_Data *debug_data;
413 Elf32_Word idx; /* Index in new file. */
414 Elf32_Word old_sh_link; /* Original value of shdr.sh_link. */
415 Elf32_Word symtab_idx;
416 Elf32_Word version_idx;
417 Elf32_Word group_idx;
418 Elf32_Word group_cnt;
420 struct Ebl_Strent *se;
421 Elf32_Word *newsymidx;
427 GElf_Ehdr newehdr_mem;
429 GElf_Ehdr debugehdr_mem;
430 GElf_Ehdr *debugehdr;
431 struct Ebl_Strtab *shst = NULL;
432 Elf_Data debuglink_crc_data;
433 bool any_symtab_changes = false;
434 Elf_Data *shstrtab_data = NULL;
435 void *debuglink_buf = NULL;
437 /* Create the full name of the file. */
440 cp = mempcpy (cp, prefix, prefix_len);
443 memcpy (cp, fname, fname_len);
445 /* If we are not replacing the input file open a new file here. */
446 if (output_fname != NULL)
448 fd = open (output_fname, O_RDWR | O_CREAT, mode);
449 if (unlikely (fd == -1))
451 error (0, errno, gettext ("cannot open '%s'"), output_fname);
458 /* Get the EBL handling. Removing all debugging symbols with the -g
459 option or resolving all relocations between debug sections with
460 the --reloc-debug-sections option are currently the only reasons
461 we need EBL so don't open the backend unless necessary. */
463 if (remove_debug || reloc_debug)
465 ebl = ebl_openbackend (elf);
468 error (0, errno, gettext ("cannot open EBL backend"));
474 /* Open the additional file the debug information will be stored in. */
475 if (debug_fname != NULL)
477 /* Create a temporary file name. We do not want to overwrite
478 the debug file if the file would not contain any
480 size_t debug_fname_len = strlen (debug_fname);
481 tmp_debug_fname = (char *) alloca (debug_fname_len + sizeof (".XXXXXX"));
482 strcpy (mempcpy (tmp_debug_fname, debug_fname, debug_fname_len),
485 debug_fd = mkstemp (tmp_debug_fname);
486 if (unlikely (debug_fd == -1))
488 error (0, errno, gettext ("cannot open '%s'"), debug_fname);
494 /* Get the information from the old file. */
496 GElf_Ehdr *ehdr = gelf_getehdr (elf, &ehdr_mem);
498 INTERNAL_ERROR (fname);
500 /* Get the section header string table index. */
501 if (unlikely (elf_getshdrstrndx (elf, &shstrndx) < 0))
502 error (EXIT_FAILURE, 0,
503 gettext ("cannot get section header string table index"));
505 /* We now create a new ELF descriptor for the same file. We
506 construct it almost exactly in the same way with some information
509 if (output_fname != NULL)
510 newelf = elf_begin (fd, ELF_C_WRITE_MMAP, NULL);
512 newelf = elf_clone (elf, ELF_C_EMPTY);
514 if (unlikely (gelf_newehdr (newelf, gelf_getclass (elf)) == 0)
515 || (ehdr->e_type != ET_REL
516 && unlikely (gelf_newphdr (newelf, ehdr->e_phnum) == 0)))
518 error (0, 0, gettext ("cannot create new file '%s': %s"),
519 output_fname, elf_errmsg (-1));
523 /* Copy over the old program header if needed. */
524 if (ehdr->e_type != ET_REL)
525 for (cnt = 0; cnt < ehdr->e_phnum; ++cnt)
528 GElf_Phdr *phdr = gelf_getphdr (elf, cnt, &phdr_mem);
530 || unlikely (gelf_update_phdr (newelf, cnt, phdr) == 0))
531 INTERNAL_ERROR (fname);
534 if (debug_fname != NULL)
536 /* Also create an ELF descriptor for the debug file */
537 debugelf = elf_begin (debug_fd, ELF_C_WRITE_MMAP, NULL);
538 if (unlikely (gelf_newehdr (debugelf, gelf_getclass (elf)) == 0)
539 || (ehdr->e_type != ET_REL
540 && unlikely (gelf_newphdr (debugelf, ehdr->e_phnum) == 0)))
542 error (0, 0, gettext ("cannot create new file '%s': %s"),
543 debug_fname, elf_errmsg (-1));
547 /* Copy over the old program header if needed. */
548 if (ehdr->e_type != ET_REL)
549 for (cnt = 0; cnt < ehdr->e_phnum; ++cnt)
552 GElf_Phdr *phdr = gelf_getphdr (elf, cnt, &phdr_mem);
554 || unlikely (gelf_update_phdr (debugelf, cnt, phdr) == 0))
555 INTERNAL_ERROR (fname);
559 /* Number of sections. */
561 if (unlikely (elf_getshdrnum (elf, &shnum) < 0))
563 error (0, 0, gettext ("cannot determine number of sections: %s"),
568 /* Storage for section information. We leave room for two more
569 entries since we unconditionally create a section header string
570 table. Maybe some weird tool created an ELF file without one.
571 The other one is used for the debug link section. */
572 if ((shnum + 2) * sizeof (struct shdr_info) > MAX_STACK_ALLOC)
573 shdr_info = (struct shdr_info *) xcalloc (shnum + 2,
574 sizeof (struct shdr_info));
577 shdr_info = (struct shdr_info *) alloca ((shnum + 2)
578 * sizeof (struct shdr_info));
579 memset (shdr_info, '\0', (shnum + 2) * sizeof (struct shdr_info));
582 /* Prepare section information data structure. */
585 while ((scn = elf_nextscn (elf, scn)) != NULL)
587 /* This should always be true (i.e., there should not be any
588 holes in the numbering). */
589 assert (elf_ndxscn (scn) == cnt);
591 shdr_info[cnt].scn = scn;
593 /* Get the header. */
594 if (gelf_getshdr (scn, &shdr_info[cnt].shdr) == NULL)
595 INTERNAL_ERROR (fname);
597 /* Get the name of the section. */
598 shdr_info[cnt].name = elf_strptr (elf, shstrndx,
599 shdr_info[cnt].shdr.sh_name);
600 if (shdr_info[cnt].name == NULL)
602 error (0, 0, gettext ("illformed file '%s'"), fname);
606 /* Mark them as present but not yet investigated. */
607 shdr_info[cnt].idx = 1;
609 /* Remember the shdr.sh_link value. */
610 shdr_info[cnt].old_sh_link = shdr_info[cnt].shdr.sh_link;
612 /* Sections in files other than relocatable object files which
613 are not loaded can be freely moved by us. In relocatable
614 object files everything can be moved. */
615 if (ehdr->e_type == ET_REL
616 || (shdr_info[cnt].shdr.sh_flags & SHF_ALLOC) == 0)
617 shdr_info[cnt].shdr.sh_offset = 0;
619 /* If this is an extended section index table store an
620 appropriate reference. */
621 if (unlikely (shdr_info[cnt].shdr.sh_type == SHT_SYMTAB_SHNDX))
623 assert (shdr_info[shdr_info[cnt].shdr.sh_link].symtab_idx == 0);
624 shdr_info[shdr_info[cnt].shdr.sh_link].symtab_idx = cnt;
626 else if (unlikely (shdr_info[cnt].shdr.sh_type == SHT_GROUP))
628 /* Cross-reference the sections contained in the section
630 shdr_info[cnt].data = elf_getdata (shdr_info[cnt].scn, NULL);
631 if (shdr_info[cnt].data == NULL)
632 INTERNAL_ERROR (fname);
634 /* XXX Fix for unaligned access. */
635 Elf32_Word *grpref = (Elf32_Word *) shdr_info[cnt].data->d_buf;
638 inner < shdr_info[cnt].data->d_size / sizeof (Elf32_Word);
640 shdr_info[grpref[inner]].group_idx = cnt;
642 if (inner == 1 || (inner == 2 && (grpref[0] & GRP_COMDAT) == 0))
643 /* If the section group contains only one element and this
644 is n COMDAT section we can drop it right away. */
645 shdr_info[cnt].idx = 0;
647 shdr_info[cnt].group_cnt = inner - 1;
649 else if (unlikely (shdr_info[cnt].shdr.sh_type == SHT_GNU_versym))
651 assert (shdr_info[shdr_info[cnt].shdr.sh_link].version_idx == 0);
652 shdr_info[shdr_info[cnt].shdr.sh_link].version_idx = cnt;
655 /* If this section is part of a group make sure it is not
656 discarded right away. */
657 if ((shdr_info[cnt].shdr.sh_flags & SHF_GROUP) != 0)
659 assert (shdr_info[cnt].group_idx != 0);
661 if (shdr_info[shdr_info[cnt].group_idx].idx == 0)
663 /* The section group section will be removed. */
664 shdr_info[cnt].group_idx = 0;
665 shdr_info[cnt].shdr.sh_flags &= ~SHF_GROUP;
669 /* Increment the counter. */
673 /* Now determine which sections can go away. The general rule is that
674 all sections which are not used at runtime are stripped out. But
675 there are a few exceptions:
677 - special sections named ".comment" and ".note" are kept
678 - OS or architecture specific sections are kept since we might not
679 know how to handle them
680 - if a section is referred to from a section which is not removed
681 in the sh_link or sh_info element it cannot be removed either
683 for (cnt = 1; cnt < shnum; ++cnt)
684 /* Check whether the section can be removed. */
685 if (remove_shdrs ? !(shdr_info[cnt].shdr.sh_flags & SHF_ALLOC)
686 : ebl_section_strip_p (ebl, ehdr, &shdr_info[cnt].shdr,
687 shdr_info[cnt].name, remove_comment,
690 /* For now assume this section will be removed. */
691 shdr_info[cnt].idx = 0;
693 idx = shdr_info[cnt].group_idx;
696 /* The section group data is already loaded. */
697 assert (shdr_info[idx].data != NULL);
699 /* If the references section group is a normal section
700 group and has one element remaining, or if it is an
701 empty COMDAT section group it is removed. */
702 bool is_comdat = (((Elf32_Word *) shdr_info[idx].data->d_buf)[0]
705 --shdr_info[idx].group_cnt;
706 if ((!is_comdat && shdr_info[idx].group_cnt == 1)
707 || (is_comdat && shdr_info[idx].group_cnt == 0))
709 shdr_info[idx].idx = 0;
710 /* Continue recursively. */
711 idx = shdr_info[idx].group_idx;
718 /* Mark the SHT_NULL section as handled. */
719 shdr_info[0].idx = 2;
722 /* Handle exceptions: section groups and cross-references. We might
723 have to repeat this a few times since the resetting of the flag
729 for (cnt = 1; cnt < shnum; ++cnt)
731 if (shdr_info[cnt].idx == 0)
733 /* If a relocation section is marked as being removed make
734 sure the section it is relocating is removed, too. */
735 if ((shdr_info[cnt].shdr.sh_type == SHT_REL
736 || shdr_info[cnt].shdr.sh_type == SHT_RELA)
737 && shdr_info[shdr_info[cnt].shdr.sh_info].idx != 0)
738 shdr_info[cnt].idx = 1;
740 /* If a group section is marked as being removed make
741 sure all the sections it contains are being removed, too. */
742 if (shdr_info[cnt].shdr.sh_type == SHT_GROUP)
745 grpref = (Elf32_Word *) shdr_info[cnt].data->d_buf;
747 in < shdr_info[cnt].data->d_size / sizeof (Elf32_Word);
749 if (shdr_info[grpref[in]].idx != 0)
751 shdr_info[cnt].idx = 1;
757 if (shdr_info[cnt].idx == 1)
759 /* The content of symbol tables we don't remove must not
760 reference any section which we do remove. Otherwise
761 we cannot remove the section. */
762 if (debug_fname != NULL
763 && shdr_info[cnt].debug_data == NULL
764 && (shdr_info[cnt].shdr.sh_type == SHT_DYNSYM
765 || shdr_info[cnt].shdr.sh_type == SHT_SYMTAB))
767 /* Make sure the data is loaded. */
768 if (shdr_info[cnt].data == NULL)
771 = elf_getdata (shdr_info[cnt].scn, NULL);
772 if (shdr_info[cnt].data == NULL)
773 INTERNAL_ERROR (fname);
775 Elf_Data *symdata = shdr_info[cnt].data;
777 /* If there is an extended section index table load it
779 if (shdr_info[cnt].symtab_idx != 0
780 && shdr_info[shdr_info[cnt].symtab_idx].data == NULL)
782 assert (shdr_info[cnt].shdr.sh_type == SHT_SYMTAB);
784 shdr_info[shdr_info[cnt].symtab_idx].data
785 = elf_getdata (shdr_info[shdr_info[cnt].symtab_idx].scn,
787 if (shdr_info[shdr_info[cnt].symtab_idx].data == NULL)
788 INTERNAL_ERROR (fname);
791 = shdr_info[shdr_info[cnt].symtab_idx].data;
793 /* Go through all symbols and make sure the section they
794 reference is not removed. */
795 size_t elsize = gelf_fsize (elf, ELF_T_SYM, 1,
798 for (size_t inner = 0;
799 inner < shdr_info[cnt].data->d_size / elsize;
804 GElf_Sym *sym = gelf_getsymshndx (symdata, xndxdata,
808 INTERNAL_ERROR (fname);
810 size_t scnidx = sym->st_shndx;
811 if (scnidx == SHN_UNDEF || scnidx >= shnum
812 || (scnidx >= SHN_LORESERVE
813 && scnidx <= SHN_HIRESERVE
814 && scnidx != SHN_XINDEX)
815 /* Don't count in the section symbols. */
816 || GELF_ST_TYPE (sym->st_info) == STT_SECTION)
817 /* This is no section index, leave it alone. */
819 else if (scnidx == SHN_XINDEX)
822 if (shdr_info[scnidx].idx == 0)
823 /* This symbol table has a real symbol in
824 a discarded section. So preserve the
825 original table in the debug file. */
826 shdr_info[cnt].debug_data = symdata;
830 /* Cross referencing happens:
831 - for the cases the ELF specification says. That are
832 + SHT_DYNAMIC in sh_link to string table
833 + SHT_HASH in sh_link to symbol table
834 + SHT_REL and SHT_RELA in sh_link to symbol table
835 + SHT_SYMTAB and SHT_DYNSYM in sh_link to string table
836 + SHT_GROUP in sh_link to symbol table
837 + SHT_SYMTAB_SHNDX in sh_link to symbol table
838 Other (OS or architecture-specific) sections might as
839 well use this field so we process it unconditionally.
840 - references inside section groups
841 - specially marked references in sh_info if the SHF_INFO_LINK
845 if (shdr_info[shdr_info[cnt].shdr.sh_link].idx == 0)
847 shdr_info[shdr_info[cnt].shdr.sh_link].idx = 1;
848 changes |= shdr_info[cnt].shdr.sh_link < cnt;
851 /* Handle references through sh_info. */
852 if (SH_INFO_LINK_P (&shdr_info[cnt].shdr)
853 && shdr_info[shdr_info[cnt].shdr.sh_info].idx == 0)
855 shdr_info[shdr_info[cnt].shdr.sh_info].idx = 1;
856 changes |= shdr_info[cnt].shdr.sh_info < cnt;
859 /* Mark the section as investigated. */
860 shdr_info[cnt].idx = 2;
863 if (debug_fname != NULL
864 && (shdr_info[cnt].idx == 0 || shdr_info[cnt].debug_data != NULL))
866 /* This section is being preserved in the debug file.
867 Sections it refers to must be preserved there too.
869 In this pass we mark sections to be preserved in both
870 files by setting the .debug_data pointer to the original
871 file's .data pointer. Below, we'll copy the section
874 inline void check_preserved (size_t i)
876 if (i != 0 && shdr_info[i].idx != 0
877 && shdr_info[i].debug_data == NULL)
879 if (shdr_info[i].data == NULL)
880 shdr_info[i].data = elf_getdata (shdr_info[i].scn, NULL);
881 if (shdr_info[i].data == NULL)
882 INTERNAL_ERROR (fname);
884 shdr_info[i].debug_data = shdr_info[i].data;
889 check_preserved (shdr_info[cnt].shdr.sh_link);
890 if (SH_INFO_LINK_P (&shdr_info[cnt].shdr))
891 check_preserved (shdr_info[cnt].shdr.sh_info);
897 /* Copy the removed sections to the debug output file.
898 The ones that are not removed in the stripped file are SHT_NOBITS. */
899 if (debug_fname != NULL)
901 for (cnt = 1; cnt < shnum; ++cnt)
903 scn = elf_newscn (debugelf);
905 error (EXIT_FAILURE, 0,
906 gettext ("while generating output file: %s"),
909 bool discard_section = (shdr_info[cnt].idx > 0
910 && shdr_info[cnt].debug_data == NULL
911 && shdr_info[cnt].shdr.sh_type != SHT_NOTE
912 && shdr_info[cnt].shdr.sh_type != SHT_GROUP
913 && cnt != ehdr->e_shstrndx);
915 /* Set the section header in the new file. */
916 GElf_Shdr debugshdr = shdr_info[cnt].shdr;
918 debugshdr.sh_type = SHT_NOBITS;
920 if (unlikely (gelf_update_shdr (scn, &debugshdr) == 0))
921 /* There cannot be any overflows. */
922 INTERNAL_ERROR (fname);
924 /* Get the data from the old file if necessary. */
925 if (shdr_info[cnt].data == NULL)
927 shdr_info[cnt].data = elf_getdata (shdr_info[cnt].scn, NULL);
928 if (shdr_info[cnt].data == NULL)
929 INTERNAL_ERROR (fname);
932 /* Set the data. This is done by copying from the old file. */
933 Elf_Data *debugdata = elf_newdata (scn);
934 if (debugdata == NULL)
935 INTERNAL_ERROR (fname);
937 /* Copy the structure. This data may be modified in place
938 before we write out the file. */
939 *debugdata = *shdr_info[cnt].data;
941 debugdata->d_buf = NULL;
942 else if (shdr_info[cnt].debug_data != NULL
943 || shdr_info[cnt].shdr.sh_type == SHT_GROUP)
945 /* Copy the original data before it gets modified. */
946 shdr_info[cnt].debug_data = debugdata;
947 debugdata->d_buf = memcpy (xmalloc (debugdata->d_size),
948 debugdata->d_buf, debugdata->d_size);
952 /* Finish the ELF header. Fill in the fields not handled by
953 libelf from the old file. */
954 debugehdr = gelf_getehdr (debugelf, &debugehdr_mem);
955 if (debugehdr == NULL)
956 INTERNAL_ERROR (fname);
958 memcpy (debugehdr->e_ident, ehdr->e_ident, EI_NIDENT);
959 debugehdr->e_type = ehdr->e_type;
960 debugehdr->e_machine = ehdr->e_machine;
961 debugehdr->e_version = ehdr->e_version;
962 debugehdr->e_entry = ehdr->e_entry;
963 debugehdr->e_flags = ehdr->e_flags;
964 debugehdr->e_shstrndx = ehdr->e_shstrndx;
966 if (unlikely (gelf_update_ehdr (debugelf, debugehdr) == 0))
968 error (0, 0, gettext ("%s: error while creating ELF header: %s"),
969 debug_fname, elf_errmsg (-1));
975 /* Mark the section header string table as unused, we will create
977 shdr_info[shstrndx].idx = 0;
979 /* We need a string table for the section headers. */
980 shst = ebl_strtabinit (true);
982 error (EXIT_FAILURE, errno, gettext ("while preparing output for '%s'"),
983 output_fname ?: fname);
985 /* Assign new section numbers. */
986 shdr_info[0].idx = 0;
987 for (cnt = idx = 1; cnt < shnum; ++cnt)
988 if (shdr_info[cnt].idx > 0)
990 shdr_info[cnt].idx = idx++;
992 /* Create a new section. */
993 shdr_info[cnt].newscn = elf_newscn (newelf);
994 if (shdr_info[cnt].newscn == NULL)
995 error (EXIT_FAILURE, 0, gettext ("while generating output file: %s"),
998 assert (elf_ndxscn (shdr_info[cnt].newscn) == shdr_info[cnt].idx);
1000 /* Add this name to the section header string table. */
1001 shdr_info[cnt].se = ebl_strtabadd (shst, shdr_info[cnt].name, 0);
1004 /* Test whether we are doing anything at all. */
1006 /* Nope, all removable sections are already gone. */
1009 /* Create the reference to the file with the debug info. */
1010 if (debug_fname != NULL && !remove_shdrs)
1012 /* Add the section header string table section name. */
1013 shdr_info[cnt].se = ebl_strtabadd (shst, ".gnu_debuglink", 15);
1014 shdr_info[cnt].idx = idx++;
1016 /* Create the section header. */
1017 shdr_info[cnt].shdr.sh_type = SHT_PROGBITS;
1018 shdr_info[cnt].shdr.sh_flags = 0;
1019 shdr_info[cnt].shdr.sh_addr = 0;
1020 shdr_info[cnt].shdr.sh_link = SHN_UNDEF;
1021 shdr_info[cnt].shdr.sh_info = SHN_UNDEF;
1022 shdr_info[cnt].shdr.sh_entsize = 0;
1023 shdr_info[cnt].shdr.sh_addralign = 4;
1024 /* We set the offset to zero here. Before we write the ELF file the
1025 field must have the correct value. This is done in the final
1026 loop over all section. Then we have all the information needed. */
1027 shdr_info[cnt].shdr.sh_offset = 0;
1029 /* Create the section. */
1030 shdr_info[cnt].newscn = elf_newscn (newelf);
1031 if (shdr_info[cnt].newscn == NULL)
1032 error (EXIT_FAILURE, 0,
1033 gettext ("while create section header section: %s"),
1035 assert (elf_ndxscn (shdr_info[cnt].newscn) == shdr_info[cnt].idx);
1037 shdr_info[cnt].data = elf_newdata (shdr_info[cnt].newscn);
1038 if (shdr_info[cnt].data == NULL)
1039 error (EXIT_FAILURE, 0, gettext ("cannot allocate section data: %s"),
1042 char *debug_basename = basename (debug_fname_embed ?: debug_fname);
1043 off_t crc_offset = strlen (debug_basename) + 1;
1044 /* Align to 4 byte boundary */
1045 crc_offset = ((crc_offset - 1) & ~3) + 4;
1047 shdr_info[cnt].data->d_align = 4;
1048 shdr_info[cnt].shdr.sh_size = shdr_info[cnt].data->d_size
1050 debuglink_buf = xcalloc (1, shdr_info[cnt].data->d_size);
1051 shdr_info[cnt].data->d_buf = debuglink_buf;
1053 strcpy (shdr_info[cnt].data->d_buf, debug_basename);
1055 /* Cache this Elf_Data describing the CRC32 word in the section.
1056 We'll fill this in when we have written the debug file. */
1057 debuglink_crc_data = *shdr_info[cnt].data;
1058 debuglink_crc_data.d_buf = ((char *) debuglink_crc_data.d_buf
1060 debuglink_crc_data.d_size = 4;
1062 /* One more section done. */
1066 /* Index of the section header table in the shdr_info array. */
1069 /* Add the section header string table section name. */
1070 shdr_info[cnt].se = ebl_strtabadd (shst, ".shstrtab", 10);
1071 shdr_info[cnt].idx = idx;
1073 /* Create the section header. */
1074 shdr_info[cnt].shdr.sh_type = SHT_STRTAB;
1075 shdr_info[cnt].shdr.sh_flags = 0;
1076 shdr_info[cnt].shdr.sh_addr = 0;
1077 shdr_info[cnt].shdr.sh_link = SHN_UNDEF;
1078 shdr_info[cnt].shdr.sh_info = SHN_UNDEF;
1079 shdr_info[cnt].shdr.sh_entsize = 0;
1080 /* We set the offset to zero here. Before we write the ELF file the
1081 field must have the correct value. This is done in the final
1082 loop over all section. Then we have all the information needed. */
1083 shdr_info[cnt].shdr.sh_offset = 0;
1084 shdr_info[cnt].shdr.sh_addralign = 1;
1086 /* Create the section. */
1087 shdr_info[cnt].newscn = elf_newscn (newelf);
1088 if (shdr_info[cnt].newscn == NULL)
1089 error (EXIT_FAILURE, 0,
1090 gettext ("while create section header section: %s"),
1092 assert (elf_ndxscn (shdr_info[cnt].newscn) == idx);
1094 /* Finalize the string table and fill in the correct indices in the
1096 shstrtab_data = elf_newdata (shdr_info[cnt].newscn);
1097 if (shstrtab_data == NULL)
1098 error (EXIT_FAILURE, 0,
1099 gettext ("while create section header string table: %s"),
1101 ebl_strtabfinalize (shst, shstrtab_data);
1103 /* We have to set the section size. */
1104 shdr_info[cnt].shdr.sh_size = shstrtab_data->d_size;
1106 /* Update the section information. */
1107 GElf_Off lastoffset = 0;
1108 for (cnt = 1; cnt <= shdridx; ++cnt)
1109 if (shdr_info[cnt].idx > 0)
1113 scn = elf_getscn (newelf, shdr_info[cnt].idx);
1114 assert (scn != NULL);
1116 /* Update the name. */
1117 shdr_info[cnt].shdr.sh_name = ebl_strtaboffset (shdr_info[cnt].se);
1119 /* Update the section header from the input file. Some fields
1120 might be section indeces which now have to be adjusted. */
1121 if (shdr_info[cnt].shdr.sh_link != 0)
1122 shdr_info[cnt].shdr.sh_link =
1123 shdr_info[shdr_info[cnt].shdr.sh_link].idx;
1125 if (shdr_info[cnt].shdr.sh_type == SHT_GROUP)
1127 assert (shdr_info[cnt].data != NULL);
1129 Elf32_Word *grpref = (Elf32_Word *) shdr_info[cnt].data->d_buf;
1130 for (size_t inner = 0;
1131 inner < shdr_info[cnt].data->d_size / sizeof (Elf32_Word);
1133 grpref[inner] = shdr_info[grpref[inner]].idx;
1136 /* Handle the SHT_REL, SHT_RELA, and SHF_INFO_LINK flag. */
1137 if (SH_INFO_LINK_P (&shdr_info[cnt].shdr))
1138 shdr_info[cnt].shdr.sh_info =
1139 shdr_info[shdr_info[cnt].shdr.sh_info].idx;
1141 /* Get the data from the old file if necessary. We already
1142 created the data for the section header string table. */
1145 if (shdr_info[cnt].data == NULL)
1147 shdr_info[cnt].data = elf_getdata (shdr_info[cnt].scn, NULL);
1148 if (shdr_info[cnt].data == NULL)
1149 INTERNAL_ERROR (fname);
1152 /* Set the data. This is done by copying from the old file. */
1153 newdata = elf_newdata (scn);
1154 if (newdata == NULL)
1155 INTERNAL_ERROR (fname);
1157 /* Copy the structure. */
1158 *newdata = *shdr_info[cnt].data;
1160 /* We know the size. */
1161 shdr_info[cnt].shdr.sh_size = shdr_info[cnt].data->d_size;
1163 /* We have to adjust symbol tables. The st_shndx member might
1164 have to be updated. */
1165 if (shdr_info[cnt].shdr.sh_type == SHT_DYNSYM
1166 || shdr_info[cnt].shdr.sh_type == SHT_SYMTAB)
1168 Elf_Data *versiondata = NULL;
1169 Elf_Data *shndxdata = NULL;
1171 size_t elsize = gelf_fsize (elf, ELF_T_SYM, 1,
1174 if (shdr_info[cnt].symtab_idx != 0)
1176 assert (shdr_info[cnt].shdr.sh_type == SHT_SYMTAB_SHNDX);
1177 /* This section has extended section information.
1178 We have to modify that information, too. */
1179 shndxdata = elf_getdata (shdr_info[shdr_info[cnt].symtab_idx].scn,
1182 assert ((versiondata->d_size / sizeof (Elf32_Word))
1183 >= shdr_info[cnt].data->d_size / elsize);
1186 if (shdr_info[cnt].version_idx != 0)
1188 assert (shdr_info[cnt].shdr.sh_type == SHT_DYNSYM);
1189 /* This section has associated version
1190 information. We have to modify that
1191 information, too. */
1192 versiondata = elf_getdata (shdr_info[shdr_info[cnt].version_idx].scn,
1195 assert ((versiondata->d_size / sizeof (GElf_Versym))
1196 >= shdr_info[cnt].data->d_size / elsize);
1199 shdr_info[cnt].newsymidx
1200 = (Elf32_Word *) xcalloc (shdr_info[cnt].data->d_size
1201 / elsize, sizeof (Elf32_Word));
1203 bool last_was_local = true;
1206 for (destidx = inner = 1;
1207 inner < shdr_info[cnt].data->d_size / elsize;
1213 GElf_Sym *sym = gelf_getsymshndx (shdr_info[cnt].data,
1217 INTERNAL_ERROR (fname);
1219 if (sym->st_shndx == SHN_UNDEF
1220 || (sym->st_shndx >= shnum
1221 && sym->st_shndx != SHN_XINDEX))
1223 /* This is no section index, leave it alone
1224 unless it is moved. */
1225 if (destidx != inner
1226 && gelf_update_symshndx (shdr_info[cnt].data,
1230 INTERNAL_ERROR (fname);
1232 shdr_info[cnt].newsymidx[inner] = destidx++;
1235 && GELF_ST_BIND (sym->st_info) != STB_LOCAL)
1237 last_was_local = false;
1238 shdr_info[cnt].shdr.sh_info = destidx - 1;
1244 /* Get the full section index, if necessary from the
1246 if (sym->st_shndx != SHN_XINDEX)
1247 sec = shdr_info[sym->st_shndx].idx;
1250 assert (shndxdata != NULL);
1252 sec = shdr_info[xshndx].idx;
1257 GElf_Section nshndx;
1260 if (sec < SHN_LORESERVE)
1267 nshndx = SHN_XINDEX;
1271 assert (sec < SHN_LORESERVE || shndxdata != NULL);
1273 if ((inner != destidx || nshndx != sym->st_shndx
1274 || (shndxdata != NULL && nxshndx != xshndx))
1275 && (sym->st_shndx = nshndx,
1276 gelf_update_symshndx (shdr_info[cnt].data,
1280 INTERNAL_ERROR (fname);
1282 shdr_info[cnt].newsymidx[inner] = destidx++;
1285 && GELF_ST_BIND (sym->st_info) != STB_LOCAL)
1287 last_was_local = false;
1288 shdr_info[cnt].shdr.sh_info = destidx - 1;
1291 else if (debug_fname == NULL
1292 || shdr_info[cnt].debug_data == NULL)
1293 /* This is a section or group signature symbol
1294 for a section which has been removed. */
1296 size_t sidx = (sym->st_shndx != SHN_XINDEX
1297 ? sym->st_shndx : xshndx);
1298 assert (GELF_ST_TYPE (sym->st_info) == STT_SECTION
1299 || (shdr_info[sidx].shdr.sh_type == SHT_GROUP
1300 && shdr_info[sidx].shdr.sh_info == inner));
1304 if (destidx != inner)
1306 /* The size of the symbol table changed. */
1307 shdr_info[cnt].shdr.sh_size = newdata->d_size
1309 any_symtab_changes = true;
1313 /* The symbol table didn't really change. */
1314 free (shdr_info[cnt].newsymidx);
1315 shdr_info[cnt].newsymidx = NULL;
1320 /* If we have to, compute the offset of the section. */
1321 if (shdr_info[cnt].shdr.sh_offset == 0)
1322 shdr_info[cnt].shdr.sh_offset
1323 = ((lastoffset + shdr_info[cnt].shdr.sh_addralign - 1)
1324 & ~((GElf_Off) (shdr_info[cnt].shdr.sh_addralign - 1)));
1326 /* Set the section header in the new file. */
1327 if (unlikely (gelf_update_shdr (scn, &shdr_info[cnt].shdr) == 0))
1328 /* There cannot be any overflows. */
1329 INTERNAL_ERROR (fname);
1331 /* Remember the last section written so far. */
1332 GElf_Off filesz = (shdr_info[cnt].shdr.sh_type != SHT_NOBITS
1333 ? shdr_info[cnt].shdr.sh_size : 0);
1334 if (lastoffset < shdr_info[cnt].shdr.sh_offset + filesz)
1335 lastoffset = shdr_info[cnt].shdr.sh_offset + filesz;
1338 /* Adjust symbol references if symbol tables changed. */
1339 if (any_symtab_changes)
1340 /* Find all relocation sections which use this symbol table. */
1341 for (cnt = 1; cnt <= shdridx; ++cnt)
1343 /* Update section headers when the data size has changed.
1344 We also update the SHT_NOBITS section in the debug
1345 file so that the section headers match in sh_size. */
1346 inline void update_section_size (const Elf_Data *newdata)
1349 GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
1350 shdr->sh_size = newdata->d_size;
1351 (void) gelf_update_shdr (scn, shdr);
1352 if (debugelf != NULL)
1354 /* libelf will use d_size to set sh_size. */
1355 Elf_Data *debugdata = elf_getdata (elf_getscn (debugelf,
1357 debugdata->d_size = newdata->d_size;
1361 if (shdr_info[cnt].idx == 0 && debug_fname == NULL)
1362 /* Ignore sections which are discarded. When we are saving a
1363 relocation section in a separate debug file, we must fix up
1364 the symbol table references. */
1367 const Elf32_Word symtabidx = shdr_info[cnt].old_sh_link;
1368 const Elf32_Word *const newsymidx = shdr_info[symtabidx].newsymidx;
1369 switch (shdr_info[cnt].shdr.sh_type)
1371 inline bool no_symtab_updates (void)
1373 /* If the symbol table hasn't changed, do not do anything. */
1374 if (shdr_info[symtabidx].newsymidx == NULL)
1377 /* If the symbol table is not discarded, but additionally
1378 duplicated in the separate debug file and this section
1379 is discarded, don't adjust anything. */
1380 return (shdr_info[cnt].idx == 0
1381 && shdr_info[symtabidx].debug_data != NULL);
1386 if (no_symtab_updates ())
1389 Elf_Data *d = elf_getdata (shdr_info[cnt].idx == 0
1390 ? elf_getscn (debugelf, cnt)
1391 : elf_getscn (newelf,
1392 shdr_info[cnt].idx),
1395 size_t nrels = (shdr_info[cnt].shdr.sh_size
1396 / shdr_info[cnt].shdr.sh_entsize);
1398 if (shdr_info[cnt].shdr.sh_type == SHT_REL)
1399 for (size_t relidx = 0; relidx < nrels; ++relidx)
1402 if (gelf_getrel (d, relidx, &rel_mem) == NULL)
1403 INTERNAL_ERROR (fname);
1405 size_t symidx = GELF_R_SYM (rel_mem.r_info);
1406 if (newsymidx[symidx] != symidx)
1409 = GELF_R_INFO (newsymidx[symidx],
1410 GELF_R_TYPE (rel_mem.r_info));
1412 if (gelf_update_rel (d, relidx, &rel_mem) == 0)
1413 INTERNAL_ERROR (fname);
1417 for (size_t relidx = 0; relidx < nrels; ++relidx)
1420 if (gelf_getrela (d, relidx, &rel_mem) == NULL)
1421 INTERNAL_ERROR (fname);
1423 size_t symidx = GELF_R_SYM (rel_mem.r_info);
1424 if (newsymidx[symidx] != symidx)
1427 = GELF_R_INFO (newsymidx[symidx],
1428 GELF_R_TYPE (rel_mem.r_info));
1430 if (gelf_update_rela (d, relidx, &rel_mem) == 0)
1431 INTERNAL_ERROR (fname);
1437 if (no_symtab_updates ())
1440 /* We have to recompute the hash table. */
1442 assert (shdr_info[cnt].idx > 0);
1444 /* The hash section in the new file. */
1445 scn = elf_getscn (newelf, shdr_info[cnt].idx);
1447 /* The symbol table data. */
1448 Elf_Data *symd = elf_getdata (elf_getscn (newelf,
1449 shdr_info[symtabidx].idx),
1451 assert (symd != NULL);
1453 /* The hash table data. */
1454 Elf_Data *hashd = elf_getdata (scn, NULL);
1455 assert (hashd != NULL);
1457 if (shdr_info[cnt].shdr.sh_entsize == sizeof (Elf32_Word))
1459 /* Sane arches first. */
1460 Elf32_Word *bucket = (Elf32_Word *) hashd->d_buf;
1462 size_t strshndx = shdr_info[symtabidx].old_sh_link;
1463 size_t elsize = gelf_fsize (elf, ELF_T_SYM, 1,
1466 /* Adjust the nchain value. The symbol table size
1467 changed. We keep the same size for the bucket array. */
1468 bucket[1] = symd->d_size / elsize;
1469 Elf32_Word nbucket = bucket[0];
1471 Elf32_Word *chain = bucket + nbucket;
1473 /* New size of the section. */
1474 hashd->d_size = ((2 + symd->d_size / elsize + nbucket)
1475 * sizeof (Elf32_Word));
1476 update_section_size (hashd);
1478 /* Clear the arrays. */
1479 memset (bucket, '\0',
1480 (symd->d_size / elsize + nbucket)
1481 * sizeof (Elf32_Word));
1483 for (size_t inner = shdr_info[symtabidx].shdr.sh_info;
1484 inner < symd->d_size / elsize; ++inner)
1487 GElf_Sym *sym = gelf_getsym (symd, inner, &sym_mem);
1488 assert (sym != NULL);
1490 const char *name = elf_strptr (elf, strshndx,
1492 assert (name != NULL);
1493 size_t hidx = elf_hash (name) % nbucket;
1495 if (bucket[hidx] == 0)
1496 bucket[hidx] = inner;
1499 hidx = bucket[hidx];
1501 while (chain[hidx] != 0)
1504 chain[hidx] = inner;
1510 /* Alpha and S390 64-bit use 64-bit SHT_HASH entries. */
1511 assert (shdr_info[cnt].shdr.sh_entsize
1512 == sizeof (Elf64_Xword));
1514 Elf64_Xword *bucket = (Elf64_Xword *) hashd->d_buf;
1516 size_t strshndx = shdr_info[symtabidx].old_sh_link;
1517 size_t elsize = gelf_fsize (elf, ELF_T_SYM, 1,
1520 /* Adjust the nchain value. The symbol table size
1521 changed. We keep the same size for the bucket array. */
1522 bucket[1] = symd->d_size / elsize;
1523 Elf64_Xword nbucket = bucket[0];
1525 Elf64_Xword *chain = bucket + nbucket;
1527 /* New size of the section. */
1528 hashd->d_size = ((2 + symd->d_size / elsize + nbucket)
1529 * sizeof (Elf64_Xword));
1530 update_section_size (hashd);
1532 /* Clear the arrays. */
1533 memset (bucket, '\0',
1534 (symd->d_size / elsize + nbucket)
1535 * sizeof (Elf64_Xword));
1537 for (size_t inner = shdr_info[symtabidx].shdr.sh_info;
1538 inner < symd->d_size / elsize; ++inner)
1541 GElf_Sym *sym = gelf_getsym (symd, inner, &sym_mem);
1542 assert (sym != NULL);
1544 const char *name = elf_strptr (elf, strshndx,
1546 assert (name != NULL);
1547 size_t hidx = elf_hash (name) % nbucket;
1549 if (bucket[hidx] == 0)
1550 bucket[hidx] = inner;
1553 hidx = bucket[hidx];
1555 while (chain[hidx] != 0)
1558 chain[hidx] = inner;
1564 case SHT_GNU_versym:
1565 /* If the symbol table changed we have to adjust the entries. */
1566 if (no_symtab_updates ())
1569 assert (shdr_info[cnt].idx > 0);
1571 /* The symbol version section in the new file. */
1572 scn = elf_getscn (newelf, shdr_info[cnt].idx);
1574 /* The symbol table data. */
1575 symd = elf_getdata (elf_getscn (newelf, shdr_info[symtabidx].idx),
1577 assert (symd != NULL);
1579 /* The version symbol data. */
1580 Elf_Data *verd = elf_getdata (scn, NULL);
1581 assert (verd != NULL);
1583 /* The symbol version array. */
1584 GElf_Half *verstab = (GElf_Half *) verd->d_buf;
1586 /* Walk through the list and */
1587 size_t elsize = gelf_fsize (elf, verd->d_type, 1,
1589 for (size_t inner = 1; inner < verd->d_size / elsize; ++inner)
1590 if (newsymidx[inner] != 0)
1591 /* Overwriting the same array works since the
1592 reordering can only move entries to lower indices
1594 verstab[newsymidx[inner]] = verstab[inner];
1596 /* New size of the section. */
1597 verd->d_size = gelf_fsize (newelf, verd->d_type,
1599 / gelf_fsize (elf, symd->d_type, 1,
1602 update_section_size (verd);
1606 if (no_symtab_updates ())
1609 /* Yes, the symbol table changed.
1610 Update the section header of the section group. */
1611 scn = elf_getscn (newelf, shdr_info[cnt].idx);
1613 GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
1614 assert (shdr != NULL);
1616 shdr->sh_info = newsymidx[shdr->sh_info];
1618 (void) gelf_update_shdr (scn, shdr);
1623 /* Remove any relocations between debug sections in ET_REL
1624 for the debug file when requested. These relocations are always
1625 zero based between the unallocated sections. */
1626 if (debug_fname != NULL && reloc_debug && ehdr->e_type == ET_REL)
1630 while ((scn = elf_nextscn (debugelf, scn)) != NULL)
1633 /* We need the actual section and header from the debugelf
1634 not just the cached original in shdr_info because we
1635 might want to change the size. */
1637 GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
1638 if (shdr->sh_type == SHT_REL || shdr->sh_type == SHT_RELA)
1640 /* Make sure that this relocation section points to a
1641 section to relocate with contents, that isn't
1642 allocated and that is a debug section. */
1643 Elf_Scn *tscn = elf_getscn (debugelf, shdr->sh_info);
1644 GElf_Shdr tshdr_mem;
1645 GElf_Shdr *tshdr = gelf_getshdr (tscn, &tshdr_mem);
1646 if (tshdr->sh_type == SHT_NOBITS
1647 || tshdr->sh_size == 0
1648 || (tshdr->sh_flags & SHF_ALLOC) != 0)
1651 const char *tname = elf_strptr (debugelf, shstrndx,
1653 if (! tname || ! ebl_debugscn_p (ebl, tname))
1656 /* OK, lets relocate all trivial cross debug section
1658 Elf_Data *reldata = elf_getdata (scn, NULL);
1659 /* We actually wanted the rawdata, but since we already
1660 accessed it earlier as elf_getdata () that won't
1661 work. But debug sections are all ELF_T_BYTE, so it
1662 doesn't really matter. */
1663 Elf_Data *tdata = elf_getdata (tscn, NULL);
1664 if (tdata->d_type != ELF_T_BYTE)
1665 INTERNAL_ERROR (fname);
1667 /* Pick up the symbol table and shndx table to
1668 resolve relocation symbol indexes. */
1669 Elf64_Word symt = shdr->sh_link;
1670 Elf_Data *symdata, *xndxdata;
1671 symdata = (shdr_info[symt].debug_data
1672 ?: shdr_info[symt].data);
1673 xndxdata = (shdr_info[shdr_info[symt].symtab_idx].debug_data
1674 ?: shdr_info[shdr_info[symt].symtab_idx].data);
1676 /* Apply one relocation. Returns true when trivial
1677 relocation actually done. */
1678 bool relocate (GElf_Addr offset, const GElf_Sxword addend,
1679 bool is_rela, int rtype, int symndx)
1681 /* R_*_NONE relocs can always just be removed. */
1685 /* We only do simple absolute relocations. */
1686 Elf_Type type = ebl_reloc_simple_type (ebl, rtype);
1687 if (type == ELF_T_NUM)
1690 /* These are the types we can relocate. */
1691 #define TYPES DO_TYPE (BYTE, Byte); DO_TYPE (HALF, Half); \
1692 DO_TYPE (WORD, Word); DO_TYPE (SWORD, Sword); \
1693 DO_TYPE (XWORD, Xword); DO_TYPE (SXWORD, Sxword)
1695 /* And only for relocations against other debug sections. */
1698 GElf_Sym *sym = gelf_getsymshndx (symdata, xndxdata,
1701 Elf32_Word sec = (sym->st_shndx == SHN_XINDEX
1702 ? xndx : sym->st_shndx);
1703 if (ebl_debugscn_p (ebl, shdr_info[sec].name))
1707 #define DO_TYPE(NAME, Name) GElf_##Name Name;
1708 union { TYPES; } tmpbuf;
1713 #define DO_TYPE(NAME, Name) \
1714 case ELF_T_##NAME: \
1715 size = sizeof (GElf_##Name); \
1724 if (offset > tdata->d_size
1725 || tdata->d_size - offset < size)
1726 error (0, 0, gettext ("bad relocation"));
1728 /* When the symbol value is zero then for SHT_REL
1729 sections this is all that needs to be checked.
1730 The addend is contained in the original data at
1731 the offset already. So if the (section) symbol
1732 address is zero and the given addend is zero
1733 just remove the relocation, it isn't needed
1735 if (addend == 0 && sym->st_value == 0)
1743 .d_version = EV_CURRENT,
1748 .d_buf = tdata->d_buf + offset,
1750 .d_version = EV_CURRENT,
1753 GElf_Addr value = sym->st_value;
1756 /* For SHT_RELA sections we just take the
1757 given addend and add it to the value. */
1762 /* For SHT_REL sections we have to peek at
1763 what is already in the section at the given
1764 offset to get the addend. */
1765 Elf_Data *d = gelf_xlatetom (debugelf, &tmpdata,
1767 ehdr->e_ident[EI_DATA]);
1769 INTERNAL_ERROR (fname);
1770 assert (d == &tmpdata);
1775 #define DO_TYPE(NAME, Name) \
1776 case ELF_T_##NAME: \
1777 tmpbuf.Name += (GElf_##Name) value; \
1785 /* Now finally put in the new value. */
1786 Elf_Data *s = gelf_xlatetof (debugelf, &rdata,
1788 ehdr->e_ident[EI_DATA]);
1790 INTERNAL_ERROR (fname);
1791 assert (s == &rdata);
1798 size_t nrels = shdr->sh_size / shdr->sh_entsize;
1800 if (shdr->sh_type == SHT_REL)
1801 for (size_t relidx = 0; relidx < nrels; ++relidx)
1804 GElf_Rel *r = gelf_getrel (reldata, relidx, &rel_mem);
1805 if (! relocate (r->r_offset, 0, false,
1806 GELF_R_TYPE (r->r_info),
1807 GELF_R_SYM (r->r_info)))
1810 gelf_update_rel (reldata, next, r);
1815 for (size_t relidx = 0; relidx < nrels; ++relidx)
1818 GElf_Rela *r = gelf_getrela (reldata, relidx, &rela_mem);
1819 if (! relocate (r->r_offset, r->r_addend, true,
1820 GELF_R_TYPE (r->r_info),
1821 GELF_R_SYM (r->r_info)))
1824 gelf_update_rela (reldata, next, r);
1830 shdr->sh_size = reldata->d_size = nrels * shdr->sh_entsize;
1831 gelf_update_shdr (scn, shdr);
1836 /* Now that we have done all adjustments to the data,
1837 we can actually write out the debug file. */
1838 if (debug_fname != NULL)
1840 /* Finally write the file. */
1841 if (unlikely (elf_update (debugelf, ELF_C_WRITE) == -1))
1843 error (0, 0, gettext ("while writing '%s': %s"),
1844 debug_fname, elf_errmsg (-1));
1849 /* Create the real output file. First rename, then change the
1851 if (rename (tmp_debug_fname, debug_fname) != 0
1852 || fchmod (debug_fd, mode) != 0)
1854 error (0, errno, gettext ("while creating '%s'"), debug_fname);
1859 /* The temporary file does not exist anymore. */
1860 tmp_debug_fname = NULL;
1865 Elf_Data debug_crc_data =
1867 .d_type = ELF_T_WORD,
1868 .d_buf = &debug_crc,
1869 .d_size = sizeof (debug_crc),
1870 .d_version = EV_CURRENT
1873 /* Compute the checksum which we will add to the executable. */
1874 if (crc32_file (debug_fd, &debug_crc) != 0)
1876 error (0, errno, gettext ("\
1877 while computing checksum for debug information"));
1878 unlink (debug_fname);
1883 /* Store it in the debuglink section data. */
1884 if (unlikely (gelf_xlatetof (newelf, &debuglink_crc_data,
1885 &debug_crc_data, ehdr->e_ident[EI_DATA])
1886 != &debuglink_crc_data))
1887 INTERNAL_ERROR (fname);
1891 /* Finally finish the ELF header. Fill in the fields not handled by
1892 libelf from the old file. */
1893 newehdr = gelf_getehdr (newelf, &newehdr_mem);
1894 if (newehdr == NULL)
1895 INTERNAL_ERROR (fname);
1897 memcpy (newehdr->e_ident, ehdr->e_ident, EI_NIDENT);
1898 newehdr->e_type = ehdr->e_type;
1899 newehdr->e_machine = ehdr->e_machine;
1900 newehdr->e_version = ehdr->e_version;
1901 newehdr->e_entry = ehdr->e_entry;
1902 newehdr->e_flags = ehdr->e_flags;
1903 newehdr->e_phoff = ehdr->e_phoff;
1905 /* We need to position the section header table. */
1906 const size_t offsize = gelf_fsize (elf, ELF_T_OFF, 1, EV_CURRENT);
1907 newehdr->e_shoff = ((shdr_info[shdridx].shdr.sh_offset
1908 + shdr_info[shdridx].shdr.sh_size + offsize - 1)
1909 & ~((GElf_Off) (offsize - 1)));
1910 newehdr->e_shentsize = gelf_fsize (elf, ELF_T_SHDR, 1, EV_CURRENT);
1912 /* The new section header string table index. */
1913 if (likely (idx < SHN_HIRESERVE) && likely (idx != SHN_XINDEX))
1914 newehdr->e_shstrndx = idx;
1917 /* The index does not fit in the ELF header field. */
1918 shdr_info[0].scn = elf_getscn (elf, 0);
1920 if (gelf_getshdr (shdr_info[0].scn, &shdr_info[0].shdr) == NULL)
1921 INTERNAL_ERROR (fname);
1923 shdr_info[0].shdr.sh_link = idx;
1924 (void) gelf_update_shdr (shdr_info[0].scn, &shdr_info[0].shdr);
1926 newehdr->e_shstrndx = SHN_XINDEX;
1929 if (gelf_update_ehdr (newelf, newehdr) == 0)
1931 error (0, 0, gettext ("%s: error while creating ELF header: %s"),
1932 fname, elf_errmsg (-1));
1936 /* We have everything from the old file. */
1937 if (elf_cntl (elf, ELF_C_FDDONE) != 0)
1939 error (0, 0, gettext ("%s: error while reading the file: %s"),
1940 fname, elf_errmsg (-1));
1944 /* The ELF library better follows our layout when this is not a
1945 relocatable object file. */
1946 elf_flagelf (newelf, ELF_C_SET,
1947 (ehdr->e_type != ET_REL ? ELF_F_LAYOUT : 0)
1948 | (permissive ? ELF_F_PERMISSIVE : 0));
1950 /* Finally write the file. */
1951 if (elf_update (newelf, ELF_C_WRITE) == -1)
1953 error (0, 0, gettext ("while writing '%s': %s"),
1954 fname, elf_errmsg (-1));
1960 /* libelf can't cope without the section headers being properly intact.
1961 So we just let it write them normally, and then we nuke them later. */
1963 if (newehdr->e_ident[EI_CLASS] == ELFCLASS32)
1965 assert (offsetof (Elf32_Ehdr, e_shentsize) + sizeof (Elf32_Half)
1966 == offsetof (Elf32_Ehdr, e_shnum));
1967 assert (offsetof (Elf32_Ehdr, e_shnum) + sizeof (Elf32_Half)
1968 == offsetof (Elf32_Ehdr, e_shstrndx));
1969 const Elf32_Off zero_off = 0;
1970 const Elf32_Half zero[3] = { 0, 0, SHN_UNDEF };
1971 if (pwrite_retry (fd, &zero_off, sizeof zero_off,
1972 offsetof (Elf32_Ehdr, e_shoff)) != sizeof zero_off
1973 || (pwrite_retry (fd, zero, sizeof zero,
1974 offsetof (Elf32_Ehdr, e_shentsize))
1976 || ftruncate64 (fd, shdr_info[shdridx].shdr.sh_offset) < 0)
1978 error (0, errno, gettext ("while writing '%s'"),
1985 assert (offsetof (Elf64_Ehdr, e_shentsize) + sizeof (Elf64_Half)
1986 == offsetof (Elf64_Ehdr, e_shnum));
1987 assert (offsetof (Elf64_Ehdr, e_shnum) + sizeof (Elf64_Half)
1988 == offsetof (Elf64_Ehdr, e_shstrndx));
1989 const Elf64_Off zero_off = 0;
1990 const Elf64_Half zero[3] = { 0, 0, SHN_UNDEF };
1991 if (pwrite_retry (fd, &zero_off, sizeof zero_off,
1992 offsetof (Elf64_Ehdr, e_shoff)) != sizeof zero_off
1993 || (pwrite_retry (fd, zero, sizeof zero,
1994 offsetof (Elf64_Ehdr, e_shentsize))
1996 || ftruncate64 (fd, shdr_info[shdridx].shdr.sh_offset) < 0)
1998 error (0, errno, gettext ("while writing '%s'"),
2006 if (shdr_info != NULL)
2008 /* For some sections we might have created an table to map symbol
2010 if (any_symtab_changes)
2011 for (cnt = 1; cnt <= shdridx; ++cnt)
2013 free (shdr_info[cnt].newsymidx);
2014 if (shdr_info[cnt].debug_data != NULL)
2015 free (shdr_info[cnt].debug_data->d_buf);
2018 /* Free data we allocated for the .gnu_debuglink section. */
2019 free (debuglink_buf);
2021 /* Free the memory. */
2022 if ((shnum + 2) * sizeof (struct shdr_info) > MAX_STACK_ALLOC)
2026 /* Free other resources. */
2027 if (shstrtab_data != NULL)
2028 free (shstrtab_data->d_buf);
2030 ebl_strtabfree (shst);
2032 /* That was it. Close the descriptors. */
2033 if (elf_end (newelf) != 0)
2035 error (0, 0, gettext ("error while finishing '%s': %s"), fname,
2040 if (debugelf != NULL && elf_end (debugelf) != 0)
2042 error (0, 0, gettext ("error while finishing '%s': %s"), debug_fname,
2048 /* Close the EBL backend. */
2050 ebl_closebackend (ebl);
2052 /* Close debug file descriptor, if opened */
2055 if (tmp_debug_fname != NULL)
2056 unlink (tmp_debug_fname);
2060 /* If requested, preserve the timestamp. */
2063 if (futimes (fd, tvp) != 0)
2065 error (0, errno, gettext ("\
2066 cannot set access and modification date of '%s'"),
2067 output_fname ?: fname);
2072 /* Close the file descriptor if we created a new file. */
2073 if (output_fname != NULL)
2081 handle_ar (int fd, Elf *elf, const char *prefix, const char *fname,
2082 struct timeval tvp[2])
2084 size_t prefix_len = prefix == NULL ? 0 : strlen (prefix);
2085 size_t fname_len = strlen (fname) + 1;
2086 char new_prefix[prefix_len + 1 + fname_len];
2087 char *cp = new_prefix;
2089 /* Create the full name of the file. */
2092 cp = mempcpy (cp, prefix, prefix_len);
2095 memcpy (cp, fname, fname_len);
2098 /* Process all the files contained in the archive. */
2100 Elf_Cmd cmd = ELF_C_RDWR;
2102 while ((subelf = elf_begin (fd, cmd, elf)) != NULL)
2104 /* The the header for this element. */
2105 Elf_Arhdr *arhdr = elf_getarhdr (subelf);
2107 if (elf_kind (subelf) == ELF_K_ELF)
2108 result |= handle_elf (fd, subelf, new_prefix, arhdr->ar_name, 0, NULL);
2109 else if (elf_kind (subelf) == ELF_K_AR)
2110 result |= handle_ar (fd, subelf, new_prefix, arhdr->ar_name, NULL);
2112 /* Get next archive element. */
2113 cmd = elf_next (subelf);
2114 if (unlikely (elf_end (subelf) != 0))
2115 INTERNAL_ERROR (fname);
2120 if (unlikely (futimes (fd, tvp) != 0))
2122 error (0, errno, gettext ("\
2123 cannot set access and modification date of '%s'"), fname);
2128 if (unlikely (close (fd) != 0))
2129 error (EXIT_FAILURE, errno, gettext ("while closing '%s'"), fname);
2135 #include "debugpred.h"