1 /* Discard section not used at runtime from object files.
2 Copyright (C) 2000-2012, 2014, 2015, 2016, 2017 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/>. */
35 #include <stdio_ext.h>
42 #include <elf-knowledge.h>
47 #include <printversion.h>
49 typedef uint8_t GElf_Byte;
51 /* Name and version of program. */
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
63 #define OPT_KEEP_SECTION 0x104
66 /* Definitions of arguments for argp functions. */
67 static const struct argp_option options[] =
69 { NULL, 0, NULL, 0, N_("Output selection:"), 0 },
70 { "output", 'o', "FILE", 0, N_("Place stripped output into FILE"), 0 },
71 { NULL, 'f', "FILE", 0, N_("Extract the removed sections into FILE"), 0 },
72 { NULL, 'F', "FILE", 0, N_("Embed name FILE instead of -f argument"), 0 },
74 { NULL, 0, NULL, 0, N_("Output options:"), 0 },
75 { "strip-all", 's', NULL, OPTION_HIDDEN, NULL, 0 },
76 { "strip-debug", 'g', NULL, 0, N_("Remove all debugging symbols"), 0 },
77 { NULL, 'd', NULL, OPTION_ALIAS, NULL, 0 },
78 { NULL, 'S', NULL, OPTION_ALIAS, NULL, 0 },
79 { "strip-sections", OPT_STRIP_SECTIONS, NULL, 0,
80 N_("Remove section headers (not recommended)"), 0 },
81 { "preserve-dates", 'p', NULL, 0,
82 N_("Copy modified/access timestamps to the output"), 0 },
83 { "reloc-debug-sections", OPT_RELOC_DEBUG, NULL, 0,
84 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 },
85 { "remove-comment", OPT_REMOVE_COMMENT, NULL, 0,
86 N_("Remove .comment section"), 0 },
87 { "remove-section", 'R', "SECTION", 0, N_("Remove the named section. SECTION is an extended wildcard pattern. May be given more than once. Only non-allocated sections can be removed."), 0 },
88 { "keep-section", OPT_KEEP_SECTION, "SECTION", 0, N_("Keep the named section. SECTION is an extended wildcard pattern. May be given more than once."), 0 },
89 { "permissive", OPT_PERMISSIVE, NULL, 0,
90 N_("Relax a few rules to handle slightly broken ELF files"), 0 },
91 { NULL, 0, NULL, 0, NULL, 0 }
94 /* Short description of program. */
95 static const char doc[] = N_("Discard symbols from object files.");
97 /* Strings for arguments in help texts. */
98 static const char args_doc[] = N_("[FILE...]");
100 /* Prototype for option handler. */
101 static error_t parse_opt (int key, char *arg, struct argp_state *state);
103 /* Data structure to communicate with argp functions. */
104 static struct argp argp =
106 options, parse_opt, args_doc, doc, NULL, NULL, NULL
110 /* Print symbols in file named FNAME. */
111 static int process_file (const char *fname);
113 /* Handle one ELF file. */
114 static int handle_elf (int fd, Elf *elf, const char *prefix,
115 const char *fname, mode_t mode, struct timespec tvp[2]);
117 /* Handle all files contained in the archive. */
118 static int handle_ar (int fd, Elf *elf, const char *prefix, const char *fname,
119 struct timespec tvp[2]) __attribute__ ((unused));
121 static int debug_fd = -1;
122 static char *tmp_debug_fname = NULL;
124 /* Close debug file descriptor, if opened. And remove temporary debug file. */
125 static void cleanup_debug (void);
127 #define INTERNAL_ERROR(fname) \
130 error (EXIT_FAILURE, 0, gettext ("%s: INTERNAL ERROR %d (%s): %s"), \
131 fname, __LINE__, PACKAGE_VERSION, elf_errmsg (-1)); \
135 /* Name of the output file. */
136 static const char *output_fname;
138 /* Name of the debug output file. */
139 static const char *debug_fname;
141 /* Name to pretend the debug output file has. */
142 static const char *debug_fname_embed;
144 /* If true output files shall have same date as the input file. */
145 static bool preserve_dates;
147 /* If true .comment sections will be removed. */
148 static bool remove_comment;
150 /* If true remove all debug sections. */
151 static bool remove_debug;
153 /* If true remove all section headers. */
154 static bool remove_shdrs;
156 /* If true relax some ELF rules for input files. */
157 static bool permissive;
159 /* If true perform relocations between debug sections. */
160 static bool reloc_debug;
162 /* Sections the user explicitly wants to keep or remove. */
163 struct section_pattern
166 struct section_pattern *next;
169 static struct section_pattern *keep_secs = NULL;
170 static struct section_pattern *remove_secs = NULL;
173 add_pattern (struct section_pattern **patterns, const char *pattern)
175 struct section_pattern *p = xmalloc (sizeof *p);
176 p->pattern = xstrdup (pattern);
182 free_sec_patterns (struct section_pattern *patterns)
184 struct section_pattern *pattern = patterns;
185 while (pattern != NULL)
187 struct section_pattern *p = pattern;
197 free_sec_patterns (keep_secs);
198 free_sec_patterns (remove_secs);
202 section_name_matches (struct section_pattern *patterns, const char *name)
204 struct section_pattern *pattern = patterns;
205 while (pattern != NULL)
207 if (fnmatch (pattern->pattern, name, FNM_EXTMATCH) == 0)
209 pattern = pattern->next;
216 main (int argc, char *argv[])
221 /* We use no threads here which can interfere with handling a stream. */
222 __fsetlocking (stdin, FSETLOCKING_BYCALLER);
223 __fsetlocking (stdout, FSETLOCKING_BYCALLER);
224 __fsetlocking (stderr, FSETLOCKING_BYCALLER);
227 setlocale (LC_ALL, "");
229 /* Make sure the message catalog can be found. */
230 bindtextdomain (PACKAGE_TARNAME, LOCALEDIR);
232 /* Initialize the message catalog. */
233 textdomain (PACKAGE_TARNAME);
235 /* Parse and process arguments. */
236 if (argp_parse (&argp, argc, argv, 0, &remaining, NULL) != 0)
239 if (reloc_debug && debug_fname == NULL)
240 error (EXIT_FAILURE, 0,
241 gettext ("--reloc-debug-sections used without -f"));
243 /* Tell the library which version we are expecting. */
244 elf_version (EV_CURRENT);
246 if (remaining == argc)
247 /* The user didn't specify a name so we use a.out. */
248 result = process_file ("a.out");
251 /* If we have seen the '-o' or '-f' option there must be exactly one
253 if ((output_fname != NULL || debug_fname != NULL)
254 && remaining + 1 < argc)
255 error (EXIT_FAILURE, 0, gettext ("\
256 Only one input file allowed together with '-o' and '-f'"));
258 /* Process all the remaining files. */
260 result |= process_file (argv[remaining]);
261 while (++remaining < argc);
269 /* Handle program arguments. */
271 parse_opt (int key, char *arg, struct argp_state *state)
276 if (debug_fname != NULL)
278 error (0, 0, gettext ("-f option specified twice"));
285 if (debug_fname_embed != NULL)
287 error (0, 0, gettext ("-F option specified twice"));
290 debug_fname_embed = arg;
294 if (output_fname != NULL)
296 error (0, 0, gettext ("-o option specified twice"));
303 preserve_dates = true;
306 case OPT_RELOC_DEBUG:
310 case OPT_REMOVE_COMMENT:
311 remove_comment = true;
315 if (fnmatch (arg, ".comment", FNM_EXTMATCH) == 0)
316 remove_comment = true;
317 add_pattern (&remove_secs, arg);
320 case OPT_KEEP_SECTION:
321 add_pattern (&keep_secs, arg);
330 case OPT_STRIP_SECTIONS:
338 case 's': /* Ignored for compatibility. */
341 case ARGP_KEY_SUCCESS:
342 if (remove_comment == true
343 && section_name_matches (keep_secs, ".comment"))
346 gettext ("cannot both keep and remove .comment section"));
352 return ARGP_ERR_UNKNOWN;
359 process_file (const char *fname)
361 /* If we have to preserve the modify and access timestamps get them
362 now. We cannot use fstat() after opening the file since the open
363 would change the access time. */
365 struct timespec tv[2];
369 if (stat (fname, &pre_st) != 0)
371 error (0, errno, gettext ("cannot stat input file '%s'"), fname);
375 /* If we have to preserve the timestamp, we need it in the
376 format utimes() understands. */
377 tv[0] = pre_st.st_atim;
378 tv[1] = pre_st.st_mtim;
382 int fd = open (fname, output_fname == NULL ? O_RDWR : O_RDONLY);
385 error (0, errno, gettext ("while opening '%s'"), fname);
389 /* We always use fstat() even if we called stat() before. This is
390 done to make sure the information returned by stat() is for the
393 if (fstat (fd, &st) != 0)
395 error (0, errno, gettext ("cannot stat input file '%s'"), fname);
398 /* Paranoid mode on. */
400 && (st.st_ino != pre_st.st_ino || st.st_dev != pre_st.st_dev))
402 /* We detected a race. Try again. */
407 /* Now get the ELF descriptor. */
408 Elf *elf = elf_begin (fd, output_fname == NULL ? ELF_C_RDWR : ELF_C_READ,
411 switch (elf_kind (elf))
414 result = handle_elf (fd, elf, NULL, fname, st.st_mode & ACCESSPERMS,
415 preserve_dates ? tv : NULL);
419 /* It is not possible to strip the content of an archive direct
420 the output to a specific file. */
421 if (unlikely (output_fname != NULL || debug_fname != NULL))
423 error (0, 0, gettext ("%s: cannot use -o or -f when stripping archive"),
429 /* We would like to support ar archives, but currently it just
430 doesn't work at all since we call elf_clone on the members
431 which doesn't really support ar members.
432 result = handle_ar (fd, elf, NULL, fname,
433 preserve_dates ? tv : NULL);
435 error (0, 0, gettext ("%s: no support for stripping archive"),
442 error (0, 0, gettext ("%s: File format not recognized"), fname);
447 if (unlikely (elf_end (elf) != 0))
448 INTERNAL_ERROR (fname);
456 /* Maximum size of array allocated on stack. */
457 #define MAX_STACK_ALLOC (400 * 1024)
460 handle_elf (int fd, Elf *elf, const char *prefix, const char *fname,
461 mode_t mode, struct timespec tvp[2])
463 size_t prefix_len = prefix == NULL ? 0 : strlen (prefix);
464 size_t fname_len = strlen (fname) + 1;
465 char *fullname = alloca (prefix_len + 1 + fname_len);
467 Elf *debugelf = NULL;
468 tmp_debug_fname = NULL;
477 Elf_Data *debug_data;
479 Elf32_Word idx; /* Index in new file. */
480 Elf32_Word old_sh_link; /* Original value of shdr.sh_link. */
481 Elf32_Word symtab_idx;
482 Elf32_Word version_idx;
483 Elf32_Word group_idx;
484 Elf32_Word group_cnt;
487 Elf32_Word *newsymidx;
493 GElf_Ehdr newehdr_mem;
495 GElf_Ehdr debugehdr_mem;
496 GElf_Ehdr *debugehdr;
497 Dwelf_Strtab *shst = NULL;
498 Elf_Data debuglink_crc_data;
499 bool any_symtab_changes = false;
500 Elf_Data *shstrtab_data = NULL;
501 void *debuglink_buf = NULL;
503 /* Create the full name of the file. */
506 cp = mempcpy (cp, prefix, prefix_len);
509 memcpy (cp, fname, fname_len);
511 /* If we are not replacing the input file open a new file here. */
512 if (output_fname != NULL)
514 fd = open (output_fname, O_RDWR | O_CREAT, mode);
515 if (unlikely (fd == -1))
517 error (0, errno, gettext ("cannot open '%s'"), output_fname);
524 /* Get the EBL handling. Removing all debugging symbols with the -g
525 option or resolving all relocations between debug sections with
526 the --reloc-debug-sections option are currently the only reasons
527 we need EBL so don't open the backend unless necessary. */
529 if (remove_debug || reloc_debug)
531 ebl = ebl_openbackend (elf);
534 error (0, errno, gettext ("cannot open EBL backend"));
540 /* Open the additional file the debug information will be stored in. */
541 if (debug_fname != NULL)
543 /* Create a temporary file name. We do not want to overwrite
544 the debug file if the file would not contain any
546 size_t debug_fname_len = strlen (debug_fname);
547 tmp_debug_fname = (char *) xmalloc (debug_fname_len + sizeof (".XXXXXX"));
548 strcpy (mempcpy (tmp_debug_fname, debug_fname, debug_fname_len),
551 debug_fd = mkstemp (tmp_debug_fname);
552 if (unlikely (debug_fd == -1))
554 error (0, errno, gettext ("cannot open '%s'"), debug_fname);
560 /* Get the information from the old file. */
562 GElf_Ehdr *ehdr = gelf_getehdr (elf, &ehdr_mem);
564 INTERNAL_ERROR (fname);
566 /* Get the section header string table index. */
567 if (unlikely (elf_getshdrstrndx (elf, &shstrndx) < 0))
570 error (EXIT_FAILURE, 0,
571 gettext ("cannot get section header string table index"));
574 /* Get the number of phdrs in the old file. */
576 if (elf_getphdrnum (elf, &phnum) != 0)
579 error (EXIT_FAILURE, 0, gettext ("cannot get number of phdrs"));
582 /* We now create a new ELF descriptor for the same file. We
583 construct it almost exactly in the same way with some information
586 if (output_fname != NULL)
587 newelf = elf_begin (fd, ELF_C_WRITE_MMAP, NULL);
589 newelf = elf_clone (elf, ELF_C_EMPTY);
591 if (unlikely (gelf_newehdr (newelf, gelf_getclass (elf)) == 0))
593 error (0, 0, gettext ("cannot create new ehdr for file '%s': %s"),
594 output_fname ?: fname, elf_errmsg (-1));
598 /* Copy over the old program header if needed. */
601 if (unlikely (gelf_newphdr (newelf, phnum) == 0))
603 error (0, 0, gettext ("cannot create new phdr for file '%s': %s"),
604 output_fname ?: fname, elf_errmsg (-1));
608 for (cnt = 0; cnt < phnum; ++cnt)
611 GElf_Phdr *phdr = gelf_getphdr (elf, cnt, &phdr_mem);
613 || unlikely (gelf_update_phdr (newelf, cnt, phdr) == 0))
614 INTERNAL_ERROR (fname);
618 if (debug_fname != NULL)
620 /* Also create an ELF descriptor for the debug file */
621 debugelf = elf_begin (debug_fd, ELF_C_WRITE_MMAP, NULL);
622 if (unlikely (gelf_newehdr (debugelf, gelf_getclass (elf)) == 0))
624 error (0, 0, gettext ("cannot create new ehdr for file '%s': %s"),
625 debug_fname, elf_errmsg (-1));
629 /* Copy over the old program header if needed. */
632 if (unlikely (gelf_newphdr (debugelf, phnum) == 0))
634 error (0, 0, gettext ("cannot create new phdr for file '%s': %s"),
635 debug_fname, elf_errmsg (-1));
639 for (cnt = 0; cnt < phnum; ++cnt)
642 GElf_Phdr *phdr = gelf_getphdr (elf, cnt, &phdr_mem);
644 || unlikely (gelf_update_phdr (debugelf, cnt, phdr) == 0))
645 INTERNAL_ERROR (fname);
650 /* Number of sections. */
652 if (unlikely (elf_getshdrnum (elf, &shnum) < 0))
654 error (0, 0, gettext ("cannot determine number of sections: %s"),
659 if (shstrndx >= shnum)
662 #define elf_assert(test) do { if (!(test)) goto illformed; } while (0)
664 /* Storage for section information. We leave room for two more
665 entries since we unconditionally create a section header string
666 table. Maybe some weird tool created an ELF file without one.
667 The other one is used for the debug link section. */
668 if ((shnum + 2) * sizeof (struct shdr_info) > MAX_STACK_ALLOC)
669 shdr_info = (struct shdr_info *) xcalloc (shnum + 2,
670 sizeof (struct shdr_info));
673 shdr_info = (struct shdr_info *) alloca ((shnum + 2)
674 * sizeof (struct shdr_info));
675 memset (shdr_info, '\0', (shnum + 2) * sizeof (struct shdr_info));
678 /* Track whether allocated sections all come before non-allocated ones. */
679 bool seen_allocated = false;
680 bool seen_unallocated = false;
681 bool mixed_allocated_unallocated = false;
683 /* Prepare section information data structure. */
686 while ((scn = elf_nextscn (elf, scn)) != NULL)
688 /* This should always be true (i.e., there should not be any
689 holes in the numbering). */
690 elf_assert (elf_ndxscn (scn) == cnt);
692 shdr_info[cnt].scn = scn;
694 /* Get the header. */
695 if (gelf_getshdr (scn, &shdr_info[cnt].shdr) == NULL)
696 INTERNAL_ERROR (fname);
698 /* Normally (in non-ET_REL files) we see all allocated sections first,
699 then all non-allocated. */
700 if ((shdr_info[cnt].shdr.sh_flags & SHF_ALLOC) == 0)
701 seen_unallocated = true;
704 if (seen_unallocated && seen_allocated)
705 mixed_allocated_unallocated = true;
706 seen_allocated = true;
709 /* Get the name of the section. */
710 shdr_info[cnt].name = elf_strptr (elf, shstrndx,
711 shdr_info[cnt].shdr.sh_name);
712 if (shdr_info[cnt].name == NULL)
715 error (0, 0, gettext ("illformed file '%s'"), fname);
719 /* Sanity check the user. */
720 if (section_name_matches (remove_secs, shdr_info[cnt].name))
722 if ((shdr_info[cnt].shdr.sh_flags & SHF_ALLOC) != 0)
725 gettext ("Cannot remove allocated section '%s'"),
726 shdr_info[cnt].name);
731 if (section_name_matches (keep_secs, shdr_info[cnt].name))
734 gettext ("Cannot both keep and remove section '%s'"),
735 shdr_info[cnt].name);
741 /* Mark them as present but not yet investigated. */
742 shdr_info[cnt].idx = 1;
744 /* Remember the shdr.sh_link value. */
745 shdr_info[cnt].old_sh_link = shdr_info[cnt].shdr.sh_link;
746 if (shdr_info[cnt].old_sh_link >= shnum)
749 /* Sections in files other than relocatable object files which
750 not loaded can be freely moved by us. In theory we can also
751 freely move around allocated nobits sections. But we don't
752 to keep the layout of all allocated sections as similar as
753 possible to the original file. In relocatable object files
754 everything can be moved. */
756 || (shdr_info[cnt].shdr.sh_flags & SHF_ALLOC) == 0)
757 shdr_info[cnt].shdr.sh_offset = 0;
759 /* If this is an extended section index table store an
760 appropriate reference. */
761 if (unlikely (shdr_info[cnt].shdr.sh_type == SHT_SYMTAB_SHNDX))
763 elf_assert (shdr_info[shdr_info[cnt].shdr.sh_link].symtab_idx == 0);
764 shdr_info[shdr_info[cnt].shdr.sh_link].symtab_idx = cnt;
766 else if (unlikely (shdr_info[cnt].shdr.sh_type == SHT_GROUP))
768 /* Cross-reference the sections contained in the section
770 shdr_info[cnt].data = elf_getdata (shdr_info[cnt].scn, NULL);
771 if (shdr_info[cnt].data == NULL
772 || shdr_info[cnt].data->d_size < sizeof (Elf32_Word))
773 INTERNAL_ERROR (fname);
775 /* XXX Fix for unaligned access. */
776 Elf32_Word *grpref = (Elf32_Word *) shdr_info[cnt].data->d_buf;
779 inner < shdr_info[cnt].data->d_size / sizeof (Elf32_Word);
782 if (grpref[inner] < shnum)
783 shdr_info[grpref[inner]].group_idx = cnt;
788 if (inner == 1 || (inner == 2 && (grpref[0] & GRP_COMDAT) == 0))
789 /* If the section group contains only one element and this
790 is n COMDAT section we can drop it right away. */
791 shdr_info[cnt].idx = 0;
793 shdr_info[cnt].group_cnt = inner - 1;
795 else if (unlikely (shdr_info[cnt].shdr.sh_type == SHT_GNU_versym))
797 elf_assert (shdr_info[shdr_info[cnt].shdr.sh_link].version_idx == 0);
798 shdr_info[shdr_info[cnt].shdr.sh_link].version_idx = cnt;
801 /* If this section is part of a group make sure it is not
802 discarded right away. */
803 if ((shdr_info[cnt].shdr.sh_flags & SHF_GROUP) != 0)
805 elf_assert (shdr_info[cnt].group_idx != 0);
807 if (shdr_info[shdr_info[cnt].group_idx].idx == 0)
809 /* The section group section might be removed.
810 Don't remove the SHF_GROUP flag. The section is
811 either also removed, in which case the flag doesn't matter.
812 Or it moves with the group into the debug file, then
813 it will be reconnected with the new group and should
814 still have the flag set. */
815 shdr_info[cnt].group_idx = 0;
819 /* Increment the counter. */
823 /* Now determine which sections can go away. The general rule is that
824 all sections which are not used at runtime are stripped out. But
825 there are a few exceptions:
827 - special sections named ".comment" and ".note" are kept
828 - OS or architecture specific sections are kept since we might not
829 know how to handle them
830 - if a section is referred to from a section which is not removed
831 in the sh_link or sh_info element it cannot be removed either
832 - the user might have explicitly said to remove or keep a section
834 for (cnt = 1; cnt < shnum; ++cnt)
835 /* Check whether the section can be removed. Since we will create
836 a new .shstrtab assume it will be removed too. */
837 if (remove_shdrs ? !(shdr_info[cnt].shdr.sh_flags & SHF_ALLOC)
838 : (ebl_section_strip_p (ebl, &shdr_info[cnt].shdr,
839 shdr_info[cnt].name, remove_comment,
842 || section_name_matches (remove_secs, shdr_info[cnt].name)))
844 /* The user might want to explicitly keep this one. */
845 if (section_name_matches (keep_secs, shdr_info[cnt].name))
848 /* For now assume this section will be removed. */
849 shdr_info[cnt].idx = 0;
851 idx = shdr_info[cnt].group_idx;
854 /* The section group data is already loaded. */
855 elf_assert (shdr_info[idx].data != NULL
856 && shdr_info[idx].data->d_buf != NULL
857 && shdr_info[idx].data->d_size >= sizeof (Elf32_Word));
859 /* If the references section group is a normal section
860 group and has one element remaining, or if it is an
861 empty COMDAT section group it is removed. */
862 bool is_comdat = (((Elf32_Word *) shdr_info[idx].data->d_buf)[0]
865 --shdr_info[idx].group_cnt;
866 if ((!is_comdat && shdr_info[idx].group_cnt == 1)
867 || (is_comdat && shdr_info[idx].group_cnt == 0))
869 shdr_info[idx].idx = 0;
870 /* Continue recursively. */
871 idx = shdr_info[idx].group_idx;
878 /* Mark the SHT_NULL section as handled. */
879 shdr_info[0].idx = 2;
882 /* Handle exceptions: section groups and cross-references. We might
883 have to repeat this a few times since the resetting of the flag
889 for (cnt = 1; cnt < shnum; ++cnt)
891 if (shdr_info[cnt].idx == 0)
893 /* If a relocation section is marked as being removed make
894 sure the section it is relocating is removed, too. */
895 if (shdr_info[cnt].shdr.sh_type == SHT_REL
896 || shdr_info[cnt].shdr.sh_type == SHT_RELA)
898 if (shdr_info[cnt].shdr.sh_info >= shnum)
900 else if (shdr_info[shdr_info[cnt].shdr.sh_info].idx != 0)
901 shdr_info[cnt].idx = 1;
904 /* If a group section is marked as being removed make
905 sure all the sections it contains are being removed, too. */
906 if (shdr_info[cnt].shdr.sh_type == SHT_GROUP)
909 grpref = (Elf32_Word *) shdr_info[cnt].data->d_buf;
911 in < shdr_info[cnt].data->d_size / sizeof (Elf32_Word);
913 if (grpref[in] < shnum)
915 if (shdr_info[grpref[in]].idx != 0)
917 shdr_info[cnt].idx = 1;
926 if (shdr_info[cnt].idx == 1)
928 /* The content of symbol tables we don't remove must not
929 reference any section which we do remove. Otherwise
930 we cannot remove the section. */
931 if (debug_fname != NULL
932 && shdr_info[cnt].debug_data == NULL
933 && (shdr_info[cnt].shdr.sh_type == SHT_DYNSYM
934 || shdr_info[cnt].shdr.sh_type == SHT_SYMTAB))
936 /* Make sure the data is loaded. */
937 if (shdr_info[cnt].data == NULL)
940 = elf_getdata (shdr_info[cnt].scn, NULL);
941 if (shdr_info[cnt].data == NULL)
942 INTERNAL_ERROR (fname);
944 Elf_Data *symdata = shdr_info[cnt].data;
946 /* If there is an extended section index table load it
948 if (shdr_info[cnt].symtab_idx != 0
949 && shdr_info[shdr_info[cnt].symtab_idx].data == NULL)
951 elf_assert (shdr_info[cnt].shdr.sh_type == SHT_SYMTAB);
953 shdr_info[shdr_info[cnt].symtab_idx].data
954 = elf_getdata (shdr_info[shdr_info[cnt].symtab_idx].scn,
956 if (shdr_info[shdr_info[cnt].symtab_idx].data == NULL)
957 INTERNAL_ERROR (fname);
960 = shdr_info[shdr_info[cnt].symtab_idx].data;
962 /* Go through all symbols and make sure the section they
963 reference is not removed. */
964 size_t elsize = gelf_fsize (elf, ELF_T_SYM, 1, EV_CURRENT);
966 for (size_t inner = 0;
967 inner < shdr_info[cnt].data->d_size / elsize;
972 GElf_Sym *sym = gelf_getsymshndx (symdata, xndxdata,
976 INTERNAL_ERROR (fname);
978 size_t scnidx = sym->st_shndx;
979 if (scnidx == SHN_UNDEF || scnidx >= shnum
980 || (scnidx >= SHN_LORESERVE
981 && scnidx <= SHN_HIRESERVE
982 && scnidx != SHN_XINDEX)
983 /* Don't count in the section symbols. */
984 || GELF_ST_TYPE (sym->st_info) == STT_SECTION)
985 /* This is no section index, leave it alone. */
987 else if (scnidx == SHN_XINDEX)
993 if (shdr_info[scnidx].idx == 0)
994 /* This symbol table has a real symbol in
995 a discarded section. So preserve the
996 original table in the debug file. Unless
997 it is a redundant data marker to a debug
998 (data only) section. */
999 if (! (ebl_section_strip_p (ebl,
1000 &shdr_info[scnidx].shdr,
1001 shdr_info[scnidx].name,
1004 && ebl_data_marker_symbol (ebl, sym,
1006 shdr_info[cnt].shdr.sh_link,
1008 shdr_info[cnt].debug_data = symdata;
1012 /* Cross referencing happens:
1013 - for the cases the ELF specification says. That are
1014 + SHT_DYNAMIC in sh_link to string table
1015 + SHT_HASH in sh_link to symbol table
1016 + SHT_REL and SHT_RELA in sh_link to symbol table
1017 + SHT_SYMTAB and SHT_DYNSYM in sh_link to string table
1018 + SHT_GROUP in sh_link to symbol table
1019 + SHT_SYMTAB_SHNDX in sh_link to symbol table
1020 Other (OS or architecture-specific) sections might as
1021 well use this field so we process it unconditionally.
1022 - references inside section groups
1023 - specially marked references in sh_info if the SHF_INFO_LINK
1027 if (shdr_info[shdr_info[cnt].shdr.sh_link].idx == 0)
1029 shdr_info[shdr_info[cnt].shdr.sh_link].idx = 1;
1030 changes |= shdr_info[cnt].shdr.sh_link < cnt;
1033 /* Handle references through sh_info. */
1034 if (SH_INFO_LINK_P (&shdr_info[cnt].shdr))
1036 if (shdr_info[cnt].shdr.sh_info >= shnum)
1038 else if ( shdr_info[shdr_info[cnt].shdr.sh_info].idx == 0)
1040 shdr_info[shdr_info[cnt].shdr.sh_info].idx = 1;
1041 changes |= shdr_info[cnt].shdr.sh_info < cnt;
1045 /* Mark the section as investigated. */
1046 shdr_info[cnt].idx = 2;
1049 if (debug_fname != NULL
1050 && (shdr_info[cnt].idx == 0 || shdr_info[cnt].debug_data != NULL))
1052 /* This section is being preserved in the debug file.
1053 Sections it refers to must be preserved there too.
1055 In this pass we mark sections to be preserved in both
1056 files by setting the .debug_data pointer to the original
1057 file's .data pointer. Below, we'll copy the section
1060 inline void check_preserved (size_t i)
1062 if (i != 0 && i < shnum + 2 && shdr_info[i].idx != 0
1063 && shdr_info[i].debug_data == NULL)
1065 if (shdr_info[i].data == NULL)
1066 shdr_info[i].data = elf_getdata (shdr_info[i].scn, NULL);
1067 if (shdr_info[i].data == NULL)
1068 INTERNAL_ERROR (fname);
1070 shdr_info[i].debug_data = shdr_info[i].data;
1075 check_preserved (shdr_info[cnt].shdr.sh_link);
1076 if (SH_INFO_LINK_P (&shdr_info[cnt].shdr))
1077 check_preserved (shdr_info[cnt].shdr.sh_info);
1083 /* Copy the removed sections to the debug output file.
1084 The ones that are not removed in the stripped file are SHT_NOBITS. */
1085 if (debug_fname != NULL)
1087 for (cnt = 1; cnt < shnum; ++cnt)
1089 scn = elf_newscn (debugelf);
1093 error (EXIT_FAILURE, 0,
1094 gettext ("while generating output file: %s"),
1098 bool discard_section = (shdr_info[cnt].idx > 0
1099 && shdr_info[cnt].debug_data == NULL
1100 && shdr_info[cnt].shdr.sh_type != SHT_NOTE
1101 && shdr_info[cnt].shdr.sh_type != SHT_GROUP
1102 && cnt != shstrndx);
1104 /* Set the section header in the new file. */
1105 GElf_Shdr debugshdr = shdr_info[cnt].shdr;
1106 if (discard_section)
1107 debugshdr.sh_type = SHT_NOBITS;
1109 if (unlikely (gelf_update_shdr (scn, &debugshdr) == 0))
1110 /* There cannot be any overflows. */
1111 INTERNAL_ERROR (fname);
1113 /* Get the data from the old file if necessary. */
1114 if (shdr_info[cnt].data == NULL)
1116 shdr_info[cnt].data = elf_getdata (shdr_info[cnt].scn, NULL);
1117 if (shdr_info[cnt].data == NULL)
1118 INTERNAL_ERROR (fname);
1121 /* Set the data. This is done by copying from the old file. */
1122 Elf_Data *debugdata = elf_newdata (scn);
1123 if (debugdata == NULL)
1124 INTERNAL_ERROR (fname);
1126 /* Copy the structure. This data may be modified in place
1127 before we write out the file. */
1128 *debugdata = *shdr_info[cnt].data;
1129 if (discard_section)
1130 debugdata->d_buf = NULL;
1131 else if (shdr_info[cnt].debug_data != NULL
1132 || shdr_info[cnt].shdr.sh_type == SHT_GROUP)
1134 /* Copy the original data before it gets modified. */
1135 shdr_info[cnt].debug_data = debugdata;
1136 if (debugdata->d_buf == NULL)
1137 INTERNAL_ERROR (fname);
1138 debugdata->d_buf = memcpy (xmalloc (debugdata->d_size),
1139 debugdata->d_buf, debugdata->d_size);
1143 /* Finish the ELF header. Fill in the fields not handled by
1144 libelf from the old file. */
1145 debugehdr = gelf_getehdr (debugelf, &debugehdr_mem);
1146 if (debugehdr == NULL)
1147 INTERNAL_ERROR (fname);
1149 memcpy (debugehdr->e_ident, ehdr->e_ident, EI_NIDENT);
1150 debugehdr->e_type = ehdr->e_type;
1151 debugehdr->e_machine = ehdr->e_machine;
1152 debugehdr->e_version = ehdr->e_version;
1153 debugehdr->e_entry = ehdr->e_entry;
1154 debugehdr->e_flags = ehdr->e_flags;
1157 if (elf_getshdrstrndx (elf, &shdrstrndx) < 0)
1159 error (0, 0, gettext ("%s: error while getting shdrstrndx: %s"),
1160 fname, elf_errmsg (-1));
1165 if (shstrndx < SHN_LORESERVE)
1166 debugehdr->e_shstrndx = shdrstrndx;
1169 debugehdr->e_shstrndx = SHN_XINDEX;
1170 Elf_Scn *scn0 = elf_getscn (debugelf, 0);
1171 GElf_Shdr shdr0_mem;
1172 GElf_Shdr *shdr0 = gelf_getshdr (scn0, &shdr0_mem);
1175 error (0, 0, gettext ("%s: error getting zero section: %s"),
1176 debug_fname, elf_errmsg (-1));
1181 shdr0->sh_link = shdrstrndx;
1182 if (gelf_update_shdr (scn0, shdr0) == 0)
1184 error (0, 0, gettext ("%s: error while updating zero section: %s"),
1185 debug_fname, elf_errmsg (-1));
1192 if (unlikely (gelf_update_ehdr (debugelf, debugehdr) == 0))
1194 error (0, 0, gettext ("%s: error while creating ELF header: %s"),
1195 debug_fname, elf_errmsg (-1));
1201 /* Although we always create a new section header string table we
1202 don't explicitly mark the existing one as unused. It can still
1203 be used through a symbol table section we are keeping. If not it
1204 will already be marked as unused. */
1206 /* We need a string table for the section headers. */
1207 shst = dwelf_strtab_init (true);
1211 error (EXIT_FAILURE, errno, gettext ("while preparing output for '%s'"),
1212 output_fname ?: fname);
1215 /* Assign new section numbers. */
1216 shdr_info[0].idx = 0;
1217 for (cnt = idx = 1; cnt < shnum; ++cnt)
1218 if (shdr_info[cnt].idx > 0)
1220 shdr_info[cnt].idx = idx++;
1222 /* Create a new section. */
1223 shdr_info[cnt].newscn = elf_newscn (newelf);
1224 if (shdr_info[cnt].newscn == NULL)
1227 error (EXIT_FAILURE, 0,
1228 gettext ("while generating output file: %s"),
1232 elf_assert (elf_ndxscn (shdr_info[cnt].newscn) == shdr_info[cnt].idx);
1234 /* Add this name to the section header string table. */
1235 shdr_info[cnt].se = dwelf_strtab_add (shst, shdr_info[cnt].name);
1238 /* Test whether we are doing anything at all. Either all removable
1239 sections are already gone. Or the only section we would remove is
1240 the .shstrtab section which we would add again. */
1241 bool removing_sections = !(cnt == idx
1243 && shdr_info[shstrndx].idx == 0));
1244 if (output_fname == NULL && !removing_sections)
1247 /* Create the reference to the file with the debug info (if any). */
1248 if (debug_fname != NULL && !remove_shdrs && removing_sections)
1250 /* Add the section header string table section name. */
1251 shdr_info[cnt].se = dwelf_strtab_add_len (shst, ".gnu_debuglink", 15);
1252 shdr_info[cnt].idx = idx++;
1254 /* Create the section header. */
1255 shdr_info[cnt].shdr.sh_type = SHT_PROGBITS;
1256 shdr_info[cnt].shdr.sh_flags = 0;
1257 shdr_info[cnt].shdr.sh_addr = 0;
1258 shdr_info[cnt].shdr.sh_link = SHN_UNDEF;
1259 shdr_info[cnt].shdr.sh_info = SHN_UNDEF;
1260 shdr_info[cnt].shdr.sh_entsize = 0;
1261 shdr_info[cnt].shdr.sh_addralign = 4;
1262 /* We set the offset to zero here. Before we write the ELF file the
1263 field must have the correct value. This is done in the final
1264 loop over all section. Then we have all the information needed. */
1265 shdr_info[cnt].shdr.sh_offset = 0;
1267 /* Create the section. */
1268 shdr_info[cnt].newscn = elf_newscn (newelf);
1269 if (shdr_info[cnt].newscn == NULL)
1272 error (EXIT_FAILURE, 0,
1273 gettext ("while create section header section: %s"),
1276 elf_assert (elf_ndxscn (shdr_info[cnt].newscn) == shdr_info[cnt].idx);
1278 shdr_info[cnt].data = elf_newdata (shdr_info[cnt].newscn);
1279 if (shdr_info[cnt].data == NULL)
1282 error (EXIT_FAILURE, 0, gettext ("cannot allocate section data: %s"),
1286 char *debug_basename = basename (debug_fname_embed ?: debug_fname);
1287 off_t crc_offset = strlen (debug_basename) + 1;
1288 /* Align to 4 byte boundary */
1289 crc_offset = ((crc_offset - 1) & ~3) + 4;
1291 shdr_info[cnt].data->d_align = 4;
1292 shdr_info[cnt].shdr.sh_size = shdr_info[cnt].data->d_size
1294 debuglink_buf = xcalloc (1, shdr_info[cnt].data->d_size);
1295 shdr_info[cnt].data->d_buf = debuglink_buf;
1297 strcpy (shdr_info[cnt].data->d_buf, debug_basename);
1299 /* Cache this Elf_Data describing the CRC32 word in the section.
1300 We'll fill this in when we have written the debug file. */
1301 debuglink_crc_data = *shdr_info[cnt].data;
1302 debuglink_crc_data.d_buf = ((char *) debuglink_crc_data.d_buf
1304 debuglink_crc_data.d_size = 4;
1306 /* One more section done. */
1310 /* Index of the section header table in the shdr_info array. */
1313 /* Add the section header string table section name. */
1314 shdr_info[cnt].se = dwelf_strtab_add_len (shst, ".shstrtab", 10);
1315 shdr_info[cnt].idx = idx;
1317 /* Create the section header. */
1318 shdr_info[cnt].shdr.sh_type = SHT_STRTAB;
1319 shdr_info[cnt].shdr.sh_flags = 0;
1320 shdr_info[cnt].shdr.sh_addr = 0;
1321 shdr_info[cnt].shdr.sh_link = SHN_UNDEF;
1322 shdr_info[cnt].shdr.sh_info = SHN_UNDEF;
1323 shdr_info[cnt].shdr.sh_entsize = 0;
1324 /* We set the offset to zero here. Before we write the ELF file the
1325 field must have the correct value. This is done in the final
1326 loop over all section. Then we have all the information needed. */
1327 shdr_info[cnt].shdr.sh_offset = 0;
1328 shdr_info[cnt].shdr.sh_addralign = 1;
1330 /* Create the section. */
1331 shdr_info[cnt].newscn = elf_newscn (newelf);
1332 if (shdr_info[cnt].newscn == NULL)
1335 error (EXIT_FAILURE, 0,
1336 gettext ("while create section header section: %s"),
1339 elf_assert (elf_ndxscn (shdr_info[cnt].newscn) == idx);
1341 /* Finalize the string table and fill in the correct indices in the
1343 shstrtab_data = elf_newdata (shdr_info[cnt].newscn);
1344 if (shstrtab_data == NULL)
1347 error (EXIT_FAILURE, 0,
1348 gettext ("while create section header string table: %s"),
1351 if (dwelf_strtab_finalize (shst, shstrtab_data) == NULL)
1354 error (EXIT_FAILURE, 0,
1355 gettext ("no memory to create section header string table"));
1358 /* We have to set the section size. */
1359 shdr_info[cnt].shdr.sh_size = shstrtab_data->d_size;
1361 /* Update the section information. */
1362 GElf_Off lastoffset = 0;
1363 for (cnt = 1; cnt <= shdridx; ++cnt)
1364 if (shdr_info[cnt].idx > 0)
1368 scn = elf_getscn (newelf, shdr_info[cnt].idx);
1369 elf_assert (scn != NULL);
1371 /* Update the name. */
1372 shdr_info[cnt].shdr.sh_name = dwelf_strent_off (shdr_info[cnt].se);
1374 /* Update the section header from the input file. Some fields
1375 might be section indeces which now have to be adjusted. Keep
1376 the index to the "current" sh_link in case we need it to lookup
1377 symbol table names. */
1378 size_t sh_link = shdr_info[cnt].shdr.sh_link;
1379 if (shdr_info[cnt].shdr.sh_link != 0)
1380 shdr_info[cnt].shdr.sh_link =
1381 shdr_info[shdr_info[cnt].shdr.sh_link].idx;
1383 if (shdr_info[cnt].shdr.sh_type == SHT_GROUP)
1385 elf_assert (shdr_info[cnt].data != NULL
1386 && shdr_info[cnt].data->d_buf != NULL);
1388 Elf32_Word *grpref = (Elf32_Word *) shdr_info[cnt].data->d_buf;
1389 /* First word is the section group flag.
1390 Followed by section indexes, that need to be renumbered. */
1391 for (size_t inner = 1;
1392 inner < shdr_info[cnt].data->d_size / sizeof (Elf32_Word);
1394 if (grpref[inner] < shnum)
1395 grpref[inner] = shdr_info[grpref[inner]].idx;
1400 /* Handle the SHT_REL, SHT_RELA, and SHF_INFO_LINK flag. */
1401 if (SH_INFO_LINK_P (&shdr_info[cnt].shdr))
1402 shdr_info[cnt].shdr.sh_info =
1403 shdr_info[shdr_info[cnt].shdr.sh_info].idx;
1405 /* Get the data from the old file if necessary. We already
1406 created the data for the section header string table. */
1409 if (shdr_info[cnt].data == NULL)
1411 shdr_info[cnt].data = elf_getdata (shdr_info[cnt].scn, NULL);
1412 if (shdr_info[cnt].data == NULL)
1413 INTERNAL_ERROR (fname);
1416 /* Set the data. This is done by copying from the old file. */
1417 newdata = elf_newdata (scn);
1418 if (newdata == NULL)
1419 INTERNAL_ERROR (fname);
1421 /* Copy the structure. */
1422 *newdata = *shdr_info[cnt].data;
1424 /* We know the size. */
1425 shdr_info[cnt].shdr.sh_size = shdr_info[cnt].data->d_size;
1427 /* We have to adjust symbol tables. The st_shndx member might
1428 have to be updated. */
1429 if (shdr_info[cnt].shdr.sh_type == SHT_DYNSYM
1430 || shdr_info[cnt].shdr.sh_type == SHT_SYMTAB)
1432 Elf_Data *versiondata = NULL;
1433 Elf_Data *shndxdata = NULL;
1435 size_t elsize = gelf_fsize (elf, ELF_T_SYM, 1, EV_CURRENT);
1437 if (shdr_info[cnt].symtab_idx != 0)
1439 elf_assert (shdr_info[cnt].shdr.sh_type == SHT_SYMTAB_SHNDX);
1440 /* This section has extended section information.
1441 We have to modify that information, too. */
1442 shndxdata = elf_getdata (shdr_info[shdr_info[cnt].symtab_idx].scn,
1445 elf_assert (shndxdata != NULL
1446 && shndxdata->d_buf != NULL
1447 && ((shndxdata->d_size / sizeof (Elf32_Word))
1448 >= shdr_info[cnt].data->d_size / elsize));
1451 if (shdr_info[cnt].version_idx != 0)
1453 elf_assert (shdr_info[cnt].shdr.sh_type == SHT_DYNSYM);
1454 /* This section has associated version
1455 information. We have to modify that
1456 information, too. */
1457 versiondata = elf_getdata (shdr_info[shdr_info[cnt].version_idx].scn,
1460 elf_assert (versiondata != NULL
1461 && versiondata->d_buf != NULL
1462 && ((versiondata->d_size / sizeof (GElf_Versym))
1463 >= shdr_info[cnt].data->d_size / elsize));
1466 shdr_info[cnt].newsymidx
1467 = (Elf32_Word *) xcalloc (shdr_info[cnt].data->d_size
1468 / elsize, sizeof (Elf32_Word));
1470 bool last_was_local = true;
1473 for (destidx = inner = 1;
1474 inner < shdr_info[cnt].data->d_size / elsize;
1480 GElf_Sym *sym = gelf_getsymshndx (shdr_info[cnt].data,
1484 INTERNAL_ERROR (fname);
1486 if (sym->st_shndx == SHN_UNDEF
1487 || (sym->st_shndx >= shnum
1488 && sym->st_shndx != SHN_XINDEX))
1490 /* This is no section index, leave it alone
1491 unless it is moved. */
1492 if (destidx != inner
1493 && gelf_update_symshndx (shdr_info[cnt].data,
1497 INTERNAL_ERROR (fname);
1499 shdr_info[cnt].newsymidx[inner] = destidx++;
1502 && GELF_ST_BIND (sym->st_info) != STB_LOCAL)
1504 last_was_local = false;
1505 shdr_info[cnt].shdr.sh_info = destidx - 1;
1511 /* Get the full section index, if necessary from the
1513 if (sym->st_shndx == SHN_XINDEX)
1514 elf_assert (shndxdata != NULL
1515 && shndxdata->d_buf != NULL);
1516 size_t sidx = (sym->st_shndx != SHN_XINDEX
1517 ? sym->st_shndx : xshndx);
1518 sec = shdr_info[sidx].idx;
1522 GElf_Section nshndx;
1525 if (sec < SHN_LORESERVE)
1532 nshndx = SHN_XINDEX;
1536 elf_assert (sec < SHN_LORESERVE || shndxdata != NULL);
1538 if ((inner != destidx || nshndx != sym->st_shndx
1539 || (shndxdata != NULL && nxshndx != xshndx))
1540 && (sym->st_shndx = nshndx,
1541 gelf_update_symshndx (shdr_info[cnt].data,
1545 INTERNAL_ERROR (fname);
1547 shdr_info[cnt].newsymidx[inner] = destidx++;
1550 && GELF_ST_BIND (sym->st_info) != STB_LOCAL)
1552 last_was_local = false;
1553 shdr_info[cnt].shdr.sh_info = destidx - 1;
1556 else if ((shdr_info[cnt].shdr.sh_flags & SHF_ALLOC) != 0
1557 && GELF_ST_TYPE (sym->st_info) != STT_SECTION
1558 && shdr_info[sidx].shdr.sh_type != SHT_GROUP)
1560 /* Removing a real symbol from an allocated
1561 symbol table is hard and probably a
1562 mistake. Really removing it means
1563 rewriting the dynamic segment and hash
1564 sections. Just warn and set the symbol
1565 section to UNDEF. */
1567 gettext ("Cannot remove symbol [%zd] from allocated symbol table [%zd]"), inner, cnt);
1568 sym->st_shndx = SHN_UNDEF;
1569 if (gelf_update_sym (shdr_info[cnt].data, destidx,
1571 INTERNAL_ERROR (fname);
1572 shdr_info[cnt].newsymidx[inner] = destidx++;
1574 else if (debug_fname != NULL
1575 && shdr_info[cnt].debug_data == NULL)
1576 /* The symbol points to a section that is discarded
1577 but isn't preserved in the debug file. Check that
1578 this is a section or group signature symbol
1579 for a section which has been removed. Or a special
1580 data marker symbol to a debug section. */
1582 elf_assert (GELF_ST_TYPE (sym->st_info) == STT_SECTION
1583 || ((shdr_info[sidx].shdr.sh_type
1585 && (shdr_info[sidx].shdr.sh_info
1587 || ebl_data_marker_symbol (ebl, sym,
1588 elf_strptr (elf, sh_link,
1593 if (destidx != inner)
1595 /* The size of the symbol table changed. */
1596 shdr_info[cnt].shdr.sh_size = newdata->d_size
1598 any_symtab_changes = true;
1602 /* The symbol table didn't really change. */
1603 free (shdr_info[cnt].newsymidx);
1604 shdr_info[cnt].newsymidx = NULL;
1609 /* If we have to, compute the offset of the section.
1610 If allocate and unallocated sections are mixed, we only update
1611 the allocated ones now. The unallocated ones come second. */
1612 if (! mixed_allocated_unallocated
1613 || (shdr_info[cnt].shdr.sh_flags & SHF_ALLOC) != 0)
1615 if (shdr_info[cnt].shdr.sh_offset == 0)
1616 shdr_info[cnt].shdr.sh_offset
1617 = ((lastoffset + shdr_info[cnt].shdr.sh_addralign - 1)
1618 & ~((GElf_Off) (shdr_info[cnt].shdr.sh_addralign - 1)));
1620 /* Set the section header in the new file. */
1621 if (unlikely (gelf_update_shdr (scn, &shdr_info[cnt].shdr) == 0))
1622 /* There cannot be any overflows. */
1623 INTERNAL_ERROR (fname);
1625 /* Remember the last section written so far. */
1626 GElf_Off filesz = (shdr_info[cnt].shdr.sh_type != SHT_NOBITS
1627 ? shdr_info[cnt].shdr.sh_size : 0);
1628 if (lastoffset < shdr_info[cnt].shdr.sh_offset + filesz)
1629 lastoffset = shdr_info[cnt].shdr.sh_offset + filesz;
1633 /* We might have to update the unallocated sections after we done the
1634 allocated ones. lastoffset is set to right after the last allocated
1636 if (mixed_allocated_unallocated)
1637 for (cnt = 1; cnt <= shdridx; ++cnt)
1638 if (shdr_info[cnt].idx > 0)
1640 scn = elf_getscn (newelf, shdr_info[cnt].idx);
1641 if ((shdr_info[cnt].shdr.sh_flags & SHF_ALLOC) == 0)
1643 if (shdr_info[cnt].shdr.sh_offset == 0)
1644 shdr_info[cnt].shdr.sh_offset
1645 = ((lastoffset + shdr_info[cnt].shdr.sh_addralign - 1)
1646 & ~((GElf_Off) (shdr_info[cnt].shdr.sh_addralign - 1)));
1648 /* Set the section header in the new file. */
1649 if (unlikely (gelf_update_shdr (scn, &shdr_info[cnt].shdr) == 0))
1650 /* There cannot be any overflows. */
1651 INTERNAL_ERROR (fname);
1653 /* Remember the last section written so far. */
1654 GElf_Off filesz = (shdr_info[cnt].shdr.sh_type != SHT_NOBITS
1655 ? shdr_info[cnt].shdr.sh_size : 0);
1656 if (lastoffset < shdr_info[cnt].shdr.sh_offset + filesz)
1657 lastoffset = shdr_info[cnt].shdr.sh_offset + filesz;
1661 /* Adjust symbol references if symbol tables changed. */
1662 if (any_symtab_changes)
1663 /* Find all relocation sections which use this symbol table. */
1664 for (cnt = 1; cnt <= shdridx; ++cnt)
1666 /* Update section headers when the data size has changed.
1667 We also update the SHT_NOBITS section in the debug
1668 file so that the section headers match in sh_size. */
1669 inline void update_section_size (const Elf_Data *newdata)
1672 GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
1673 shdr->sh_size = newdata->d_size;
1674 (void) gelf_update_shdr (scn, shdr);
1675 if (debugelf != NULL)
1677 /* libelf will use d_size to set sh_size. */
1678 Elf_Data *debugdata = elf_getdata (elf_getscn (debugelf,
1680 if (debugdata == NULL)
1681 INTERNAL_ERROR (fname);
1682 debugdata->d_size = newdata->d_size;
1686 if (shdr_info[cnt].idx == 0 && debug_fname == NULL)
1687 /* Ignore sections which are discarded. When we are saving a
1688 relocation section in a separate debug file, we must fix up
1689 the symbol table references. */
1692 const Elf32_Word symtabidx = shdr_info[cnt].old_sh_link;
1693 elf_assert (symtabidx < shnum + 2);
1694 const Elf32_Word *const newsymidx = shdr_info[symtabidx].newsymidx;
1695 switch (shdr_info[cnt].shdr.sh_type)
1697 inline bool no_symtab_updates (void)
1699 /* If the symbol table hasn't changed, do not do anything. */
1700 if (shdr_info[symtabidx].newsymidx == NULL)
1703 /* If the symbol table is not discarded, but additionally
1704 duplicated in the separate debug file and this section
1705 is discarded, don't adjust anything. */
1706 return (shdr_info[cnt].idx == 0
1707 && shdr_info[symtabidx].debug_data != NULL);
1712 if (no_symtab_updates ())
1715 Elf_Data *d = elf_getdata (shdr_info[cnt].idx == 0
1716 ? elf_getscn (debugelf, cnt)
1717 : elf_getscn (newelf,
1718 shdr_info[cnt].idx),
1720 elf_assert (d != NULL && d->d_buf != NULL
1721 && shdr_info[cnt].shdr.sh_entsize != 0);
1722 size_t nrels = (shdr_info[cnt].shdr.sh_size
1723 / shdr_info[cnt].shdr.sh_entsize);
1725 size_t symsize = gelf_fsize (elf, ELF_T_SYM, 1, EV_CURRENT);
1726 const Elf32_Word symidxn = (shdr_info[symtabidx].data->d_size
1728 if (shdr_info[cnt].shdr.sh_type == SHT_REL)
1729 for (size_t relidx = 0; relidx < nrels; ++relidx)
1732 if (gelf_getrel (d, relidx, &rel_mem) == NULL)
1733 INTERNAL_ERROR (fname);
1735 size_t symidx = GELF_R_SYM (rel_mem.r_info);
1736 elf_assert (symidx < symidxn);
1737 if (newsymidx[symidx] != symidx)
1740 = GELF_R_INFO (newsymidx[symidx],
1741 GELF_R_TYPE (rel_mem.r_info));
1743 if (gelf_update_rel (d, relidx, &rel_mem) == 0)
1744 INTERNAL_ERROR (fname);
1748 for (size_t relidx = 0; relidx < nrels; ++relidx)
1751 if (gelf_getrela (d, relidx, &rel_mem) == NULL)
1752 INTERNAL_ERROR (fname);
1754 size_t symidx = GELF_R_SYM (rel_mem.r_info);
1755 elf_assert (symidx < symidxn);
1756 if (newsymidx[symidx] != symidx)
1759 = GELF_R_INFO (newsymidx[symidx],
1760 GELF_R_TYPE (rel_mem.r_info));
1762 if (gelf_update_rela (d, relidx, &rel_mem) == 0)
1763 INTERNAL_ERROR (fname);
1769 if (no_symtab_updates ())
1772 /* We have to recompute the hash table. */
1774 elf_assert (shdr_info[cnt].idx > 0);
1776 /* The hash section in the new file. */
1777 scn = elf_getscn (newelf, shdr_info[cnt].idx);
1779 /* The symbol table data. */
1780 Elf_Data *symd = elf_getdata (elf_getscn (newelf,
1781 shdr_info[symtabidx].idx),
1783 elf_assert (symd != NULL && symd->d_buf != NULL);
1785 /* The hash table data. */
1786 Elf_Data *hashd = elf_getdata (scn, NULL);
1787 elf_assert (hashd != NULL && hashd->d_buf != NULL);
1789 if (shdr_info[cnt].shdr.sh_entsize == sizeof (Elf32_Word))
1791 /* Sane arches first. */
1792 elf_assert (hashd->d_size >= 2 * sizeof (Elf32_Word));
1793 Elf32_Word *bucket = (Elf32_Word *) hashd->d_buf;
1795 size_t strshndx = shdr_info[symtabidx].old_sh_link;
1796 size_t elsize = gelf_fsize (elf, ELF_T_SYM, 1, EV_CURRENT);
1798 Elf32_Word nchain = bucket[1];
1799 Elf32_Word nbucket = bucket[0];
1800 uint64_t used_buf = ((2ULL + nchain + nbucket)
1801 * sizeof (Elf32_Word));
1802 elf_assert (used_buf <= hashd->d_size);
1804 /* Adjust the nchain value. The symbol table size
1805 changed. We keep the same size for the bucket array. */
1806 bucket[1] = symd->d_size / elsize;
1808 Elf32_Word *chain = bucket + nbucket;
1810 /* New size of the section. */
1811 size_t n_size = ((2 + symd->d_size / elsize + nbucket)
1812 * sizeof (Elf32_Word));
1813 elf_assert (n_size <= hashd->d_size);
1814 hashd->d_size = n_size;
1815 update_section_size (hashd);
1817 /* Clear the arrays. */
1818 memset (bucket, '\0',
1819 (symd->d_size / elsize + nbucket)
1820 * sizeof (Elf32_Word));
1822 for (size_t inner = shdr_info[symtabidx].shdr.sh_info;
1823 inner < symd->d_size / elsize; ++inner)
1826 GElf_Sym *sym = gelf_getsym (symd, inner, &sym_mem);
1827 elf_assert (sym != NULL);
1829 const char *name = elf_strptr (elf, strshndx,
1831 elf_assert (name != NULL && nbucket != 0);
1832 size_t hidx = elf_hash (name) % nbucket;
1834 if (bucket[hidx] == 0)
1835 bucket[hidx] = inner;
1838 hidx = bucket[hidx];
1840 while (chain[hidx] != 0 && chain[hidx] < nchain)
1843 chain[hidx] = inner;
1849 /* Alpha and S390 64-bit use 64-bit SHT_HASH entries. */
1850 elf_assert (shdr_info[cnt].shdr.sh_entsize
1851 == sizeof (Elf64_Xword));
1853 Elf64_Xword *bucket = (Elf64_Xword *) hashd->d_buf;
1855 size_t strshndx = shdr_info[symtabidx].old_sh_link;
1856 size_t elsize = gelf_fsize (elf, ELF_T_SYM, 1, EV_CURRENT);
1858 elf_assert (symd->d_size >= 2 * sizeof (Elf64_Xword));
1859 Elf64_Xword nbucket = bucket[0];
1860 Elf64_Xword nchain = bucket[1];
1861 uint64_t maxwords = hashd->d_size / sizeof (Elf64_Xword);
1862 elf_assert (maxwords >= 2
1863 && maxwords - 2 >= nbucket
1864 && maxwords - 2 - nbucket >= nchain);
1866 /* Adjust the nchain value. The symbol table size
1867 changed. We keep the same size for the bucket array. */
1868 bucket[1] = symd->d_size / elsize;
1870 Elf64_Xword *chain = bucket + nbucket;
1872 /* New size of the section. */
1873 size_t n_size = ((2 + symd->d_size / elsize + nbucket)
1874 * sizeof (Elf64_Xword));
1875 elf_assert (n_size <= hashd->d_size);
1876 hashd->d_size = n_size;
1877 update_section_size (hashd);
1879 /* Clear the arrays. */
1880 memset (bucket, '\0',
1881 (symd->d_size / elsize + nbucket)
1882 * sizeof (Elf64_Xword));
1884 for (size_t inner = shdr_info[symtabidx].shdr.sh_info;
1885 inner < symd->d_size / elsize; ++inner)
1888 GElf_Sym *sym = gelf_getsym (symd, inner, &sym_mem);
1889 elf_assert (sym != NULL);
1891 const char *name = elf_strptr (elf, strshndx,
1893 elf_assert (name != NULL && nbucket != 0);
1894 size_t hidx = elf_hash (name) % nbucket;
1896 if (bucket[hidx] == 0)
1897 bucket[hidx] = inner;
1900 hidx = bucket[hidx];
1902 while (chain[hidx] != 0 && chain[hidx] < nchain)
1905 chain[hidx] = inner;
1911 case SHT_GNU_versym:
1912 /* If the symbol table changed we have to adjust the entries. */
1913 if (no_symtab_updates ())
1916 elf_assert (shdr_info[cnt].idx > 0);
1918 /* The symbol version section in the new file. */
1919 scn = elf_getscn (newelf, shdr_info[cnt].idx);
1921 /* The symbol table data. */
1922 symd = elf_getdata (elf_getscn (newelf, shdr_info[symtabidx].idx),
1924 elf_assert (symd != NULL && symd->d_buf != NULL);
1925 size_t symz = gelf_fsize (elf, ELF_T_SYM, 1, EV_CURRENT);
1926 const Elf32_Word syms = (shdr_info[symtabidx].data->d_size / symz);
1928 /* The version symbol data. */
1929 Elf_Data *verd = elf_getdata (scn, NULL);
1930 elf_assert (verd != NULL && verd->d_buf != NULL);
1932 /* The symbol version array. */
1933 GElf_Half *verstab = (GElf_Half *) verd->d_buf;
1935 /* Walk through the list and */
1936 size_t elsize = gelf_fsize (elf, verd->d_type, 1, EV_CURRENT);
1937 Elf32_Word vers = verd->d_size / elsize;
1938 for (size_t inner = 1; inner < vers && inner < syms; ++inner)
1939 if (newsymidx[inner] != 0 && newsymidx[inner] < vers)
1940 /* Overwriting the same array works since the
1941 reordering can only move entries to lower indices
1943 verstab[newsymidx[inner]] = verstab[inner];
1945 /* New size of the section. */
1946 verd->d_size = gelf_fsize (newelf, verd->d_type,
1948 / gelf_fsize (elf, symd->d_type, 1,
1951 update_section_size (verd);
1955 if (no_symtab_updates ())
1958 /* Yes, the symbol table changed.
1959 Update the section header of the section group. */
1960 scn = elf_getscn (newelf, shdr_info[cnt].idx);
1962 GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
1963 elf_assert (shdr != NULL);
1965 size_t symsz = gelf_fsize (elf, ELF_T_SYM, 1, EV_CURRENT);
1966 const Elf32_Word symn = (shdr_info[symtabidx].data->d_size
1968 elf_assert (shdr->sh_info < symn);
1969 shdr->sh_info = newsymidx[shdr->sh_info];
1971 (void) gelf_update_shdr (scn, shdr);
1976 /* Remove any relocations between debug sections in ET_REL
1977 for the debug file when requested. These relocations are always
1978 zero based between the unallocated sections. */
1979 if (debug_fname != NULL && removing_sections
1980 && reloc_debug && ehdr->e_type == ET_REL)
1984 while ((scn = elf_nextscn (debugelf, scn)) != NULL)
1987 /* We need the actual section and header from the debugelf
1988 not just the cached original in shdr_info because we
1989 might want to change the size. */
1991 GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
1992 if (shdr->sh_type == SHT_REL || shdr->sh_type == SHT_RELA)
1994 /* Make sure that this relocation section points to a
1995 section to relocate with contents, that isn't
1996 allocated and that is a debug section. */
1997 Elf_Scn *tscn = elf_getscn (debugelf, shdr->sh_info);
1998 GElf_Shdr tshdr_mem;
1999 GElf_Shdr *tshdr = gelf_getshdr (tscn, &tshdr_mem);
2000 if (tshdr->sh_type == SHT_NOBITS
2001 || tshdr->sh_size == 0
2002 || (tshdr->sh_flags & SHF_ALLOC) != 0)
2005 const char *tname = elf_strptr (debugelf, shstrndx,
2007 if (! tname || ! ebl_debugscn_p (ebl, tname))
2010 /* OK, lets relocate all trivial cross debug section
2012 Elf_Data *reldata = elf_getdata (scn, NULL);
2013 if (reldata == NULL || reldata->d_buf == NULL)
2014 INTERNAL_ERROR (fname);
2016 /* Make sure we adjust the uncompressed debug data
2017 (and recompress if necessary at the end). */
2019 int tcompress_type = 0;
2020 if (gelf_getchdr (tscn, &tchdr) != NULL)
2022 tcompress_type = tchdr.ch_type;
2023 if (elf_compress (tscn, 0, 0) != 1)
2024 INTERNAL_ERROR (fname);
2027 Elf_Data *tdata = elf_getdata (tscn, NULL);
2028 if (tdata == NULL || tdata->d_buf == NULL
2029 || tdata->d_type != ELF_T_BYTE)
2030 INTERNAL_ERROR (fname);
2032 /* Pick up the symbol table and shndx table to
2033 resolve relocation symbol indexes. */
2034 Elf64_Word symt = shdr->sh_link;
2035 Elf_Data *symdata, *xndxdata;
2036 elf_assert (symt < shnum + 2);
2037 elf_assert (shdr_info[symt].symtab_idx < shnum + 2);
2038 symdata = (shdr_info[symt].debug_data
2039 ?: shdr_info[symt].data);
2040 xndxdata = (shdr_info[shdr_info[symt].symtab_idx].debug_data
2041 ?: shdr_info[shdr_info[symt].symtab_idx].data);
2043 /* Apply one relocation. Returns true when trivial
2044 relocation actually done. */
2045 bool relocate (GElf_Addr offset, const GElf_Sxword addend,
2046 bool is_rela, int rtype, int symndx)
2048 /* R_*_NONE relocs can always just be removed. */
2052 /* We only do simple absolute relocations. */
2054 Elf_Type type = ebl_reloc_simple_type (ebl, rtype, &addsub);
2055 if (type == ELF_T_NUM)
2058 /* These are the types we can relocate. */
2059 #define TYPES DO_TYPE (BYTE, Byte); DO_TYPE (HALF, Half); \
2060 DO_TYPE (WORD, Word); DO_TYPE (SWORD, Sword); \
2061 DO_TYPE (XWORD, Xword); DO_TYPE (SXWORD, Sxword)
2063 /* And only for relocations against other debug sections. */
2066 GElf_Sym *sym = gelf_getsymshndx (symdata, xndxdata,
2069 Elf32_Word sec = (sym->st_shndx == SHN_XINDEX
2070 ? xndx : sym->st_shndx);
2071 if (sec >= shnum + 2)
2072 INTERNAL_ERROR (fname);
2074 if (ebl_debugscn_p (ebl, shdr_info[sec].name))
2078 #define DO_TYPE(NAME, Name) GElf_##Name Name;
2079 union { TYPES; } tmpbuf;
2084 #define DO_TYPE(NAME, Name) \
2085 case ELF_T_##NAME: \
2086 size = sizeof (GElf_##Name); \
2095 if (offset > tdata->d_size
2096 || tdata->d_size - offset < size)
2099 error (EXIT_FAILURE, 0, gettext ("bad relocation"));
2102 /* When the symbol value is zero then for SHT_REL
2103 sections this is all that needs to be checked.
2104 The addend is contained in the original data at
2105 the offset already. So if the (section) symbol
2106 address is zero and the given addend is zero
2107 just remove the relocation, it isn't needed
2109 if (addend == 0 && sym->st_value == 0)
2117 .d_version = EV_CURRENT,
2122 .d_buf = tdata->d_buf + offset,
2124 .d_version = EV_CURRENT,
2127 GElf_Addr value = sym->st_value;
2130 /* For SHT_RELA sections we just take the
2131 given addend and add it to the value. */
2133 /* For ADD/SUB relocations we need to fetch the
2134 current section contents. */
2137 Elf_Data *d = gelf_xlatetom (debugelf, &tmpdata,
2139 ehdr->e_ident[EI_DATA]);
2141 INTERNAL_ERROR (fname);
2142 assert (d == &tmpdata);
2147 /* For SHT_REL sections we have to peek at
2148 what is already in the section at the given
2149 offset to get the addend. */
2150 Elf_Data *d = gelf_xlatetom (debugelf, &tmpdata,
2152 ehdr->e_ident[EI_DATA]);
2154 INTERNAL_ERROR (fname);
2155 assert (d == &tmpdata);
2160 #define DO_TYPE(NAME, Name) \
2161 case ELF_T_##NAME: \
2163 tmpbuf.Name -= (GElf_##Name) value; \
2165 tmpbuf.Name += (GElf_##Name) value; \
2173 /* Now finally put in the new value. */
2174 Elf_Data *s = gelf_xlatetof (debugelf, &rdata,
2176 ehdr->e_ident[EI_DATA]);
2178 INTERNAL_ERROR (fname);
2179 assert (s == &rdata);
2186 if (shdr->sh_entsize == 0)
2187 INTERNAL_ERROR (fname);
2189 size_t nrels = shdr->sh_size / shdr->sh_entsize;
2191 if (shdr->sh_type == SHT_REL)
2192 for (size_t relidx = 0; relidx < nrels; ++relidx)
2195 GElf_Rel *r = gelf_getrel (reldata, relidx, &rel_mem);
2196 if (! relocate (r->r_offset, 0, false,
2197 GELF_R_TYPE (r->r_info),
2198 GELF_R_SYM (r->r_info)))
2201 gelf_update_rel (reldata, next, r);
2206 for (size_t relidx = 0; relidx < nrels; ++relidx)
2209 GElf_Rela *r = gelf_getrela (reldata, relidx, &rela_mem);
2210 if (! relocate (r->r_offset, r->r_addend, true,
2211 GELF_R_TYPE (r->r_info),
2212 GELF_R_SYM (r->r_info)))
2215 gelf_update_rela (reldata, next, r);
2221 shdr->sh_size = reldata->d_size = nrels * shdr->sh_entsize;
2222 gelf_update_shdr (scn, shdr);
2224 if (tcompress_type != 0)
2225 if (elf_compress (tscn, tcompress_type, ELF_CHF_FORCE) != 1)
2226 INTERNAL_ERROR (fname);
2231 /* Now that we have done all adjustments to the data,
2232 we can actually write out the debug file. */
2233 if (debug_fname != NULL && removing_sections)
2235 /* Finally write the file. */
2236 if (unlikely (elf_update (debugelf, ELF_C_WRITE) == -1))
2238 error (0, 0, gettext ("while writing '%s': %s"),
2239 tmp_debug_fname, elf_errmsg (-1));
2244 /* Create the real output file. First rename, then change the
2246 if (rename (tmp_debug_fname, debug_fname) != 0
2247 || fchmod (debug_fd, mode) != 0)
2249 error (0, errno, gettext ("while creating '%s'"), debug_fname);
2254 /* The temporary file does not exist anymore. */
2255 free (tmp_debug_fname);
2256 tmp_debug_fname = NULL;
2261 Elf_Data debug_crc_data =
2263 .d_type = ELF_T_WORD,
2264 .d_buf = &debug_crc,
2265 .d_size = sizeof (debug_crc),
2266 .d_version = EV_CURRENT
2269 /* Compute the checksum which we will add to the executable. */
2270 if (crc32_file (debug_fd, &debug_crc) != 0)
2272 error (0, errno, gettext ("\
2273 while computing checksum for debug information"));
2274 unlink (debug_fname);
2279 /* Store it in the debuglink section data. */
2280 if (unlikely (gelf_xlatetof (newelf, &debuglink_crc_data,
2281 &debug_crc_data, ehdr->e_ident[EI_DATA])
2282 != &debuglink_crc_data))
2283 INTERNAL_ERROR (fname);
2287 /* Finally finish the ELF header. Fill in the fields not handled by
2288 libelf from the old file. */
2289 newehdr = gelf_getehdr (newelf, &newehdr_mem);
2290 if (newehdr == NULL)
2291 INTERNAL_ERROR (fname);
2293 memcpy (newehdr->e_ident, ehdr->e_ident, EI_NIDENT);
2294 newehdr->e_type = ehdr->e_type;
2295 newehdr->e_machine = ehdr->e_machine;
2296 newehdr->e_version = ehdr->e_version;
2297 newehdr->e_entry = ehdr->e_entry;
2298 newehdr->e_flags = ehdr->e_flags;
2299 newehdr->e_phoff = ehdr->e_phoff;
2301 /* We need to position the section header table. */
2302 const size_t offsize = gelf_fsize (elf, ELF_T_OFF, 1, EV_CURRENT);
2303 newehdr->e_shoff = ((shdr_info[shdridx].shdr.sh_offset
2304 + shdr_info[shdridx].shdr.sh_size + offsize - 1)
2305 & ~((GElf_Off) (offsize - 1)));
2306 newehdr->e_shentsize = gelf_fsize (elf, ELF_T_SHDR, 1, EV_CURRENT);
2308 /* The new section header string table index. */
2309 if (likely (idx < SHN_HIRESERVE) && likely (idx != SHN_XINDEX))
2310 newehdr->e_shstrndx = idx;
2313 /* The index does not fit in the ELF header field. */
2314 shdr_info[0].scn = elf_getscn (elf, 0);
2316 if (gelf_getshdr (shdr_info[0].scn, &shdr_info[0].shdr) == NULL)
2317 INTERNAL_ERROR (fname);
2319 shdr_info[0].shdr.sh_link = idx;
2320 (void) gelf_update_shdr (shdr_info[0].scn, &shdr_info[0].shdr);
2322 newehdr->e_shstrndx = SHN_XINDEX;
2325 if (gelf_update_ehdr (newelf, newehdr) == 0)
2327 error (0, 0, gettext ("%s: error while creating ELF header: %s"),
2328 output_fname ?: fname, elf_errmsg (-1));
2333 /* We have everything from the old file. */
2334 if (elf_cntl (elf, ELF_C_FDDONE) != 0)
2336 error (0, 0, gettext ("%s: error while reading the file: %s"),
2337 fname, elf_errmsg (-1));
2342 /* The ELF library better follows our layout when this is not a
2343 relocatable object file. */
2344 elf_flagelf (newelf, ELF_C_SET,
2345 (phnum > 0 ? ELF_F_LAYOUT : 0)
2346 | (permissive ? ELF_F_PERMISSIVE : 0));
2348 /* Finally write the file. */
2349 if (elf_update (newelf, ELF_C_WRITE) == -1)
2351 error (0, 0, gettext ("while writing '%s': %s"),
2352 output_fname ?: fname, elf_errmsg (-1));
2358 /* libelf can't cope without the section headers being properly intact.
2359 So we just let it write them normally, and then we nuke them later. */
2361 if (newehdr->e_ident[EI_CLASS] == ELFCLASS32)
2363 assert (offsetof (Elf32_Ehdr, e_shentsize) + sizeof (Elf32_Half)
2364 == offsetof (Elf32_Ehdr, e_shnum));
2365 assert (offsetof (Elf32_Ehdr, e_shnum) + sizeof (Elf32_Half)
2366 == offsetof (Elf32_Ehdr, e_shstrndx));
2367 const Elf32_Off zero_off = 0;
2368 const Elf32_Half zero[3] = { 0, 0, SHN_UNDEF };
2369 if (pwrite_retry (fd, &zero_off, sizeof zero_off,
2370 offsetof (Elf32_Ehdr, e_shoff)) != sizeof zero_off
2371 || (pwrite_retry (fd, zero, sizeof zero,
2372 offsetof (Elf32_Ehdr, e_shentsize))
2374 || ftruncate (fd, shdr_info[shdridx].shdr.sh_offset) < 0)
2376 error (0, errno, gettext ("while writing '%s'"),
2377 output_fname ?: fname);
2383 assert (offsetof (Elf64_Ehdr, e_shentsize) + sizeof (Elf64_Half)
2384 == offsetof (Elf64_Ehdr, e_shnum));
2385 assert (offsetof (Elf64_Ehdr, e_shnum) + sizeof (Elf64_Half)
2386 == offsetof (Elf64_Ehdr, e_shstrndx));
2387 const Elf64_Off zero_off = 0;
2388 const Elf64_Half zero[3] = { 0, 0, SHN_UNDEF };
2389 if (pwrite_retry (fd, &zero_off, sizeof zero_off,
2390 offsetof (Elf64_Ehdr, e_shoff)) != sizeof zero_off
2391 || (pwrite_retry (fd, zero, sizeof zero,
2392 offsetof (Elf64_Ehdr, e_shentsize))
2394 || ftruncate (fd, shdr_info[shdridx].shdr.sh_offset) < 0)
2396 error (0, errno, gettext ("while writing '%s'"),
2397 output_fname ?: fname);
2404 if (shdr_info != NULL)
2406 /* For some sections we might have created an table to map symbol
2407 table indices. Or we might kept (original) data around to put
2408 into the .debug file. */
2409 for (cnt = 1; cnt <= shdridx; ++cnt)
2411 free (shdr_info[cnt].newsymidx);
2412 if (shdr_info[cnt].debug_data != NULL)
2413 free (shdr_info[cnt].debug_data->d_buf);
2416 /* Free data we allocated for the .gnu_debuglink section. */
2417 free (debuglink_buf);
2419 /* Free the memory. */
2420 if ((shnum + 2) * sizeof (struct shdr_info) > MAX_STACK_ALLOC)
2424 /* Free other resources. */
2425 if (shstrtab_data != NULL)
2426 free (shstrtab_data->d_buf);
2428 dwelf_strtab_free (shst);
2430 /* That was it. Close the descriptors. */
2431 if (elf_end (newelf) != 0)
2433 error (0, 0, gettext ("error while finishing '%s': %s"),
2434 output_fname ?: fname, elf_errmsg (-1));
2438 if (debugelf != NULL && elf_end (debugelf) != 0)
2440 error (0, 0, gettext ("error while finishing '%s': %s"), debug_fname,
2446 /* Close the EBL backend. */
2448 ebl_closebackend (ebl);
2452 /* If requested, preserve the timestamp. */
2455 if (futimens (fd, tvp) != 0)
2457 error (0, errno, gettext ("\
2458 cannot set access and modification date of '%s'"),
2459 output_fname ?: fname);
2464 /* Close the file descriptor if we created a new file. */
2465 if (output_fname != NULL)
2469 unlink (output_fname);
2476 cleanup_debug (void)
2480 if (tmp_debug_fname != NULL)
2482 unlink (tmp_debug_fname);
2483 free (tmp_debug_fname);
2484 tmp_debug_fname = NULL;
2492 handle_ar (int fd, Elf *elf, const char *prefix, const char *fname,
2493 struct timespec tvp[2])
2495 size_t prefix_len = prefix == NULL ? 0 : strlen (prefix);
2496 size_t fname_len = strlen (fname) + 1;
2497 char new_prefix[prefix_len + 1 + fname_len];
2498 char *cp = new_prefix;
2500 /* Create the full name of the file. */
2503 cp = mempcpy (cp, prefix, prefix_len);
2506 memcpy (cp, fname, fname_len);
2509 /* Process all the files contained in the archive. */
2511 Elf_Cmd cmd = ELF_C_RDWR;
2513 while ((subelf = elf_begin (fd, cmd, elf)) != NULL)
2515 /* The the header for this element. */
2516 Elf_Arhdr *arhdr = elf_getarhdr (subelf);
2518 if (elf_kind (subelf) == ELF_K_ELF)
2519 result |= handle_elf (fd, subelf, new_prefix, arhdr->ar_name, 0, NULL);
2520 else if (elf_kind (subelf) == ELF_K_AR)
2521 result |= handle_ar (fd, subelf, new_prefix, arhdr->ar_name, NULL);
2523 /* Get next archive element. */
2524 cmd = elf_next (subelf);
2525 if (unlikely (elf_end (subelf) != 0))
2526 INTERNAL_ERROR (fname);
2531 if (unlikely (futimens (fd, tvp) != 0))
2533 error (0, errno, gettext ("\
2534 cannot set access and modification date of '%s'"), fname);
2539 if (unlikely (close (fd) != 0))
2540 error (EXIT_FAILURE, errno, gettext ("while closing '%s'"), fname);
2546 #include "debugpred.h"