1 /* Discard section not used at runtime from object files. 2 Copyright (C) 2000-2012 Red Hat, Inc. 3 This file is part of Red Hat elfutils. 4 Written by Ulrich Drepper <drepper (at) redhat.com>, 2000. 5 6 Red Hat elfutils is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by the 8 Free Software Foundation; version 2 of the License. 9 10 Red Hat elfutils is distributed in the hope that it will be useful, but 11 WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 General Public License for more details. 14 15 You should have received a copy of the GNU General Public License along 16 with Red Hat elfutils; if not, write to the Free Software Foundation, 17 Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA. 18 19 Red Hat elfutils is an included package of the Open Invention Network. 20 An included package of the Open Invention Network is a package for which 21 Open Invention Network licensees cross-license their patents. No patent 22 license is granted, either expressly or impliedly, by designation as an 23 included package. Should you wish to participate in the Open Invention 24 Network licensing program, please visit www.openinventionnetwork.com 25 <http://www.openinventionnetwork.com>. */ 26 27 #ifdef HAVE_CONFIG_H 28 # include <config.h> 29 #endif 30 31 #include <argp.h> 32 #include <assert.h> 33 #include <byteswap.h> 34 #include <endian.h> 35 #include <error.h> 36 #include <fcntl.h> 37 #include <gelf.h> 38 #include <libelf.h> 39 #include <libintl.h> 40 #include <locale.h> 41 #include <mcheck.h> 42 #include <stdbool.h> 43 #include <stdio.h> 44 #include <stdio_ext.h> 45 #include <stdlib.h> 46 #include <string.h> 47 #include <unistd.h> 48 #include <sys/param.h> 49 #include <sys/stat.h> 50 #include <sys/time.h> 51 52 #include <elf-knowledge.h> 53 #include <libebl.h> 54 #include <system.h> 55 56 typedef uint8_t GElf_Byte; 57 58 /* Name and version of program. */ 59 static void print_version (FILE *stream, struct argp_state *state); 60 ARGP_PROGRAM_VERSION_HOOK_DEF = print_version; 61 62 /* Bug report address. */ 63 ARGP_PROGRAM_BUG_ADDRESS_DEF = PACKAGE_BUGREPORT; 64 65 66 /* Values for the parameters which have no short form. */ 67 #define OPT_REMOVE_COMMENT 0x100 68 #define OPT_PERMISSIVE 0x101 69 #define OPT_STRIP_SECTIONS 0x102 70 #define OPT_RELOC_DEBUG 0x103 71 72 73 /* Definitions of arguments for argp functions. */ 74 static const struct argp_option options[] = 75 { 76 { NULL, 0, NULL, 0, N_("Output selection:"), 0 }, 77 { "output", 'o', "FILE", 0, N_("Place stripped output into FILE"), 0 }, 78 { NULL, 'f', "FILE", 0, N_("Extract the removed sections into FILE"), 0 }, 79 { NULL, 'F', "FILE", 0, N_("Embed name FILE instead of -f argument"), 0 }, 80 81 { NULL, 0, NULL, 0, N_("Output options:"), 0 }, 82 { "strip-all", 's', NULL, OPTION_HIDDEN, NULL, 0 }, 83 { "strip-debug", 'g', NULL, 0, N_("Remove all debugging symbols"), 0 }, 84 { NULL, 'd', NULL, OPTION_ALIAS, NULL, 0 }, 85 { NULL, 'S', NULL, OPTION_ALIAS, NULL, 0 }, 86 { "strip-sections", OPT_STRIP_SECTIONS, NULL, 0, 87 N_("Remove section headers (not recommended)"), 0 }, 88 { "preserve-dates", 'p', NULL, 0, 89 N_("Copy modified/access timestamps to the output"), 0 }, 90 { "reloc-debug-sections", OPT_RELOC_DEBUG, NULL, 0, 91 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 }, 92 { "remove-comment", OPT_REMOVE_COMMENT, NULL, 0, 93 N_("Remove .comment section"), 0 }, 94 { "remove-section", 'R', "SECTION", OPTION_HIDDEN, NULL, 0 }, 95 { "permissive", OPT_PERMISSIVE, NULL, 0, 96 N_("Relax a few rules to handle slightly broken ELF files"), 0 }, 97 { NULL, 0, NULL, 0, NULL, 0 } 98 }; 99 100 /* Short description of program. */ 101 static const char doc[] = N_("Discard symbols from object files."); 102 103 /* Strings for arguments in help texts. */ 104 static const char args_doc[] = N_("[FILE...]"); 105 106 /* Prototype for option handler. */ 107 static error_t parse_opt (int key, char *arg, struct argp_state *state); 108 109 /* Data structure to communicate with argp functions. */ 110 static struct argp argp = 111 { 112 options, parse_opt, args_doc, doc, NULL, NULL, NULL 113 }; 114 115 116 /* Print symbols in file named FNAME. */ 117 static int process_file (const char *fname); 118 119 /* Handle one ELF file. */ 120 static int handle_elf (int fd, Elf *elf, const char *prefix, 121 const char *fname, mode_t mode, struct timeval tvp[2]); 122 123 /* Handle all files contained in the archive. */ 124 static int handle_ar (int fd, Elf *elf, const char *prefix, const char *fname, 125 struct timeval tvp[2]); 126 127 #define INTERNAL_ERROR(fname) \ 128 error (EXIT_FAILURE, 0, gettext ("%s: INTERNAL ERROR %d (%s-%s): %s"), \ 129 fname, __LINE__, PACKAGE_VERSION, __DATE__, elf_errmsg (-1)) 130 131 132 /* Name of the output file. */ 133 static const char *output_fname; 134 135 /* Name of the debug output file. */ 136 static const char *debug_fname; 137 138 /* Name to pretend the debug output file has. */ 139 static const char *debug_fname_embed; 140 141 /* If true output files shall have same date as the input file. */ 142 static bool preserve_dates; 143 144 /* If true .comment sections will be removed. */ 145 static bool remove_comment; 146 147 /* If true remove all debug sections. */ 148 static bool remove_debug; 149 150 /* If true remove all section headers. */ 151 static bool remove_shdrs; 152 153 /* If true relax some ELF rules for input files. */ 154 static bool permissive; 155 156 /* If true perform relocations between debug sections. */ 157 static bool reloc_debug; 158 159 160 int 161 main (int argc, char *argv[]) 162 { 163 int remaining; 164 int result = 0; 165 166 /* Make memory leak detection possible. */ 167 mtrace (); 168 169 /* We use no threads here which can interfere with handling a stream. */ 170 __fsetlocking (stdin, FSETLOCKING_BYCALLER); 171 __fsetlocking (stdout, FSETLOCKING_BYCALLER); 172 __fsetlocking (stderr, FSETLOCKING_BYCALLER); 173 174 /* Set locale. */ 175 setlocale (LC_ALL, ""); 176 177 /* Make sure the message catalog can be found. */ 178 bindtextdomain (PACKAGE_TARNAME, LOCALEDIR); 179 180 /* Initialize the message catalog. */ 181 textdomain (PACKAGE_TARNAME); 182 183 /* Parse and process arguments. */ 184 if (argp_parse (&argp, argc, argv, 0, &remaining, NULL) != 0) 185 return EXIT_FAILURE; 186 187 if (reloc_debug && debug_fname == NULL) 188 error (EXIT_FAILURE, 0, 189 gettext ("--reloc-debug-sections used without -f")); 190 191 /* Tell the library which version we are expecting. */ 192 elf_version (EV_CURRENT); 193 194 if (remaining == argc) 195 /* The user didn't specify a name so we use a.out. */ 196 result = process_file ("a.out"); 197 else 198 { 199 /* If we have seen the '-o' or '-f' option there must be exactly one 200 input file. */ 201 if ((output_fname != NULL || debug_fname != NULL) 202 && remaining + 1 < argc) 203 error (EXIT_FAILURE, 0, gettext ("\ 204 Only one input file allowed together with '-o' and '-f'")); 205 206 /* Process all the remaining files. */ 207 do 208 result |= process_file (argv[remaining]); 209 while (++remaining < argc); 210 } 211 212 return result; 213 } 214 215 216 /* Print the version information. */ 217 static void 218 print_version (FILE *stream, struct argp_state *state __attribute__ ((unused))) 219 { 220 fprintf (stream, "strip (%s) %s\n", PACKAGE_NAME, PACKAGE_VERSION); 221 fprintf (stream, gettext ("\ 222 Copyright (C) %s Red Hat, Inc.\n\ 223 This is free software; see the source for copying conditions. There is NO\n\ 224 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\ 225 "), "2012"); 226 fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper"); 227 } 228 229 230 /* Handle program arguments. */ 231 static error_t 232 parse_opt (int key, char *arg, struct argp_state *state) 233 { 234 switch (key) 235 { 236 case 'f': 237 if (debug_fname != NULL) 238 { 239 error (0, 0, gettext ("-f option specified twice")); 240 return EINVAL; 241 } 242 debug_fname = arg; 243 break; 244 245 case 'F': 246 if (debug_fname_embed != NULL) 247 { 248 error (0, 0, gettext ("-F option specified twice")); 249 return EINVAL; 250 } 251 debug_fname_embed = arg; 252 break; 253 254 case 'o': 255 if (output_fname != NULL) 256 { 257 error (0, 0, gettext ("-o option specified twice")); 258 return EINVAL; 259 } 260 output_fname = arg; 261 break; 262 263 case 'p': 264 preserve_dates = true; 265 break; 266 267 case OPT_RELOC_DEBUG: 268 reloc_debug = true; 269 break; 270 271 case OPT_REMOVE_COMMENT: 272 remove_comment = true; 273 break; 274 275 case 'R': 276 if (!strcmp (arg, ".comment")) 277 remove_comment = true; 278 else 279 { 280 argp_error (state, 281 gettext ("-R option supports only .comment section")); 282 return EINVAL; 283 } 284 break; 285 286 case 'g': 287 case 'd': 288 case 'S': 289 remove_debug = true; 290 break; 291 292 case OPT_STRIP_SECTIONS: 293 remove_shdrs = true; 294 break; 295 296 case OPT_PERMISSIVE: 297 permissive = true; 298 break; 299 300 case 's': /* Ignored for compatibility. */ 301 break; 302 303 default: 304 return ARGP_ERR_UNKNOWN; 305 } 306 return 0; 307 } 308 309 310 static int 311 process_file (const char *fname) 312 { 313 /* If we have to preserve the modify and access timestamps get them 314 now. We cannot use fstat() after opening the file since the open 315 would change the access time. */ 316 struct stat64 pre_st; 317 struct timeval tv[2]; 318 again: 319 if (preserve_dates) 320 { 321 if (stat64 (fname, &pre_st) != 0) 322 { 323 error (0, errno, gettext ("cannot stat input file '%s'"), fname); 324 return 1; 325 } 326 327 /* If we have to preserve the timestamp, we need it in the 328 format utimes() understands. */ 329 TIMESPEC_TO_TIMEVAL (&tv[0], &pre_st.st_atim); 330 TIMESPEC_TO_TIMEVAL (&tv[1], &pre_st.st_mtim); 331 } 332 333 /* Open the file. */ 334 int fd = open (fname, output_fname == NULL ? O_RDWR : O_RDONLY); 335 if (fd == -1) 336 { 337 error (0, errno, gettext ("while opening '%s'"), fname); 338 return 1; 339 } 340 341 /* We always use fstat() even if we called stat() before. This is 342 done to make sure the information returned by stat() is for the 343 same file. */ 344 struct stat64 st; 345 if (fstat64 (fd, &st) != 0) 346 { 347 error (0, errno, gettext ("cannot stat input file '%s'"), fname); 348 return 1; 349 } 350 /* Paranoid mode on. */ 351 if (preserve_dates 352 && (st.st_ino != pre_st.st_ino || st.st_dev != pre_st.st_dev)) 353 { 354 /* We detected a race. Try again. */ 355 close (fd); 356 goto again; 357 } 358 359 /* Now get the ELF descriptor. */ 360 Elf *elf = elf_begin (fd, output_fname == NULL ? ELF_C_RDWR : ELF_C_READ, 361 NULL); 362 int result; 363 switch (elf_kind (elf)) 364 { 365 case ELF_K_ELF: 366 result = handle_elf (fd, elf, NULL, fname, st.st_mode & ACCESSPERMS, 367 preserve_dates ? tv : NULL); 368 break; 369 370 case ELF_K_AR: 371 /* It is not possible to strip the content of an archive direct 372 the output to a specific file. */ 373 if (unlikely (output_fname != NULL || debug_fname != NULL)) 374 { 375 error (0, 0, gettext ("%s: cannot use -o or -f when stripping archive"), 376 fname); 377 result = 1; 378 } 379 else 380 result = handle_ar (fd, elf, NULL, fname, preserve_dates ? tv : NULL); 381 break; 382 383 default: 384 error (0, 0, gettext ("%s: File format not recognized"), fname); 385 result = 1; 386 break; 387 } 388 389 if (unlikely (elf_end (elf) != 0)) 390 INTERNAL_ERROR (fname); 391 392 close (fd); 393 394 return result; 395 } 396 397 398 /* Maximum size of array allocated on stack. */ 399 #define MAX_STACK_ALLOC (400 * 1024) 400 401 static int 402 handle_elf (int fd, Elf *elf, const char *prefix, const char *fname, 403 mode_t mode, struct timeval tvp[2]) 404 { 405 size_t prefix_len = prefix == NULL ? 0 : strlen (prefix); 406 size_t fname_len = strlen (fname) + 1; 407 char *fullname = alloca (prefix_len + 1 + fname_len); 408 char *cp = fullname; 409 Elf *debugelf = NULL; 410 char *tmp_debug_fname = NULL; 411 int result = 0; 412 size_t shdridx = 0; 413 size_t shstrndx; 414 struct shdr_info 415 { 416 Elf_Scn *scn; 417 GElf_Shdr shdr; 418 Elf_Data *data; 419 Elf_Data *debug_data; 420 const char *name; 421 Elf32_Word idx; /* Index in new file. */ 422 Elf32_Word old_sh_link; /* Original value of shdr.sh_link. */ 423 Elf32_Word symtab_idx; 424 Elf32_Word version_idx; 425 Elf32_Word group_idx; 426 Elf32_Word group_cnt; 427 Elf_Scn *newscn; 428 struct Ebl_Strent *se; 429 Elf32_Word *newsymidx; 430 } *shdr_info = NULL; 431 Elf_Scn *scn; 432 size_t cnt; 433 size_t idx; 434 bool changes; 435 GElf_Ehdr newehdr_mem; 436 GElf_Ehdr *newehdr; 437 GElf_Ehdr debugehdr_mem; 438 GElf_Ehdr *debugehdr; 439 struct Ebl_Strtab *shst = NULL; 440 Elf_Data debuglink_crc_data; 441 bool any_symtab_changes = false; 442 Elf_Data *shstrtab_data = NULL; 443 444 /* Create the full name of the file. */ 445 if (prefix != NULL) 446 { 447 cp = mempcpy (cp, prefix, prefix_len); 448 *cp++ = ':'; 449 } 450 memcpy (cp, fname, fname_len); 451 452 /* If we are not replacing the input file open a new file here. */ 453 if (output_fname != NULL) 454 { 455 fd = open (output_fname, O_RDWR | O_CREAT, mode); 456 if (unlikely (fd == -1)) 457 { 458 error (0, errno, gettext ("cannot open '%s'"), output_fname); 459 return 1; 460 } 461 } 462 463 int debug_fd = -1; 464 465 /* Get the EBL handling. Removing all debugging symbols with the -g 466 option or resolving all relocations between debug sections with 467 the --reloc-debug-sections option are currently the only reasons 468 we need EBL so don't open the backend unless necessary. */ 469 Ebl *ebl = NULL; 470 if (remove_debug || reloc_debug) 471 { 472 ebl = ebl_openbackend (elf); 473 if (ebl == NULL) 474 { 475 error (0, errno, gettext ("cannot open EBL backend")); 476 result = 1; 477 goto fail; 478 } 479 } 480 481 /* Open the additional file the debug information will be stored in. */ 482 if (debug_fname != NULL) 483 { 484 /* Create a temporary file name. We do not want to overwrite 485 the debug file if the file would not contain any 486 information. */ 487 size_t debug_fname_len = strlen (debug_fname); 488 tmp_debug_fname = (char *) alloca (debug_fname_len + sizeof (".XXXXXX")); 489 strcpy (mempcpy (tmp_debug_fname, debug_fname, debug_fname_len), 490 ".XXXXXX"); 491 492 debug_fd = mkstemp (tmp_debug_fname); 493 if (unlikely (debug_fd == -1)) 494 { 495 error (0, errno, gettext ("cannot open '%s'"), debug_fname); 496 result = 1; 497 goto fail; 498 } 499 } 500 501 /* Get the information from the old file. */ 502 GElf_Ehdr ehdr_mem; 503 GElf_Ehdr *ehdr = gelf_getehdr (elf, &ehdr_mem); 504 if (ehdr == NULL) 505 INTERNAL_ERROR (fname); 506 507 /* Get the section header string table index. */ 508 if (unlikely (elf_getshdrstrndx (elf, &shstrndx) < 0)) 509 error (EXIT_FAILURE, 0, 510 gettext ("cannot get section header string table index")); 511 512 /* We now create a new ELF descriptor for the same file. We 513 construct it almost exactly in the same way with some information 514 dropped. */ 515 Elf *newelf; 516 if (output_fname != NULL) 517 newelf = elf_begin (fd, ELF_C_WRITE_MMAP, NULL); 518 else 519 newelf = elf_clone (elf, ELF_C_EMPTY); 520 521 if (unlikely (gelf_newehdr (newelf, gelf_getclass (elf)) == 0) 522 || (ehdr->e_type != ET_REL 523 && unlikely (gelf_newphdr (newelf, ehdr->e_phnum) == 0))) 524 { 525 error (0, 0, gettext ("cannot create new file '%s': %s"), 526 output_fname, elf_errmsg (-1)); 527 goto fail; 528 } 529 530 /* Copy over the old program header if needed. */ 531 if (ehdr->e_type != ET_REL) 532 for (cnt = 0; cnt < ehdr->e_phnum; ++cnt) 533 { 534 GElf_Phdr phdr_mem; 535 GElf_Phdr *phdr = gelf_getphdr (elf, cnt, &phdr_mem); 536 if (phdr == NULL 537 || unlikely (gelf_update_phdr (newelf, cnt, phdr) == 0)) 538 INTERNAL_ERROR (fname); 539 } 540 541 if (debug_fname != NULL) 542 { 543 /* Also create an ELF descriptor for the debug file */ 544 debugelf = elf_begin (debug_fd, ELF_C_WRITE_MMAP, NULL); 545 if (unlikely (gelf_newehdr (debugelf, gelf_getclass (elf)) == 0) 546 || (ehdr->e_type != ET_REL 547 && unlikely (gelf_newphdr (debugelf, ehdr->e_phnum) == 0))) 548 { 549 error (0, 0, gettext ("cannot create new file '%s': %s"), 550 debug_fname, elf_errmsg (-1)); 551 goto fail_close; 552 } 553 554 /* Copy over the old program header if needed. */ 555 if (ehdr->e_type != ET_REL) 556 for (cnt = 0; cnt < ehdr->e_phnum; ++cnt) 557 { 558 GElf_Phdr phdr_mem; 559 GElf_Phdr *phdr = gelf_getphdr (elf, cnt, &phdr_mem); 560 if (phdr == NULL 561 || unlikely (gelf_update_phdr (debugelf, cnt, phdr) == 0)) 562 INTERNAL_ERROR (fname); 563 } 564 } 565 566 /* Number of sections. */ 567 size_t shnum; 568 if (unlikely (elf_getshdrnum (elf, &shnum) < 0)) 569 { 570 error (0, 0, gettext ("cannot determine number of sections: %s"), 571 elf_errmsg (-1)); 572 goto fail_close; 573 } 574 575 /* Storage for section information. We leave room for two more 576 entries since we unconditionally create a section header string 577 table. Maybe some weird tool created an ELF file without one. 578 The other one is used for the debug link section. */ 579 if ((shnum + 2) * sizeof (struct shdr_info) > MAX_STACK_ALLOC) 580 shdr_info = (struct shdr_info *) xcalloc (shnum + 2, 581 sizeof (struct shdr_info)); 582 else 583 { 584 shdr_info = (struct shdr_info *) alloca ((shnum + 2) 585 * sizeof (struct shdr_info)); 586 memset (shdr_info, '\0', (shnum + 2) * sizeof (struct shdr_info)); 587 } 588 589 /* Prepare section information data structure. */ 590 scn = NULL; 591 cnt = 1; 592 while ((scn = elf_nextscn (elf, scn)) != NULL) 593 { 594 /* This should always be true (i.e., there should not be any 595 holes in the numbering). */ 596 assert (elf_ndxscn (scn) == cnt); 597 598 shdr_info[cnt].scn = scn; 599 600 /* Get the header. */ 601 if (gelf_getshdr (scn, &shdr_info[cnt].shdr) == NULL) 602 INTERNAL_ERROR (fname); 603 604 /* Get the name of the section. */ 605 shdr_info[cnt].name = elf_strptr (elf, shstrndx, 606 shdr_info[cnt].shdr.sh_name); 607 if (shdr_info[cnt].name == NULL) 608 { 609 error (0, 0, gettext ("illformed file '%s'"), fname); 610 goto fail_close; 611 } 612 613 /* Mark them as present but not yet investigated. */ 614 shdr_info[cnt].idx = 1; 615 616 /* Remember the shdr.sh_link value. */ 617 shdr_info[cnt].old_sh_link = shdr_info[cnt].shdr.sh_link; 618 619 /* Sections in files other than relocatable object files which 620 are not loaded can be freely moved by us. In relocatable 621 object files everything can be moved. */ 622 if (ehdr->e_type == ET_REL 623 || (shdr_info[cnt].shdr.sh_flags & SHF_ALLOC) == 0) 624 shdr_info[cnt].shdr.sh_offset = 0; 625 626 /* If this is an extended section index table store an 627 appropriate reference. */ 628 if (unlikely (shdr_info[cnt].shdr.sh_type == SHT_SYMTAB_SHNDX)) 629 { 630 assert (shdr_info[shdr_info[cnt].shdr.sh_link].symtab_idx == 0); 631 shdr_info[shdr_info[cnt].shdr.sh_link].symtab_idx = cnt; 632 } 633 else if (unlikely (shdr_info[cnt].shdr.sh_type == SHT_GROUP)) 634 { 635 /* Cross-reference the sections contained in the section 636 group. */ 637 shdr_info[cnt].data = elf_getdata (shdr_info[cnt].scn, NULL); 638 if (shdr_info[cnt].data == NULL) 639 INTERNAL_ERROR (fname); 640 641 /* XXX Fix for unaligned access. */ 642 Elf32_Word *grpref = (Elf32_Word *) shdr_info[cnt].data->d_buf; 643 size_t inner; 644 for (inner = 1; 645 inner < shdr_info[cnt].data->d_size / sizeof (Elf32_Word); 646 ++inner) 647 shdr_info[grpref[inner]].group_idx = cnt; 648 649 if (inner == 1 || (inner == 2 && (grpref[0] & GRP_COMDAT) == 0)) 650 /* If the section group contains only one element and this 651 is n COMDAT section we can drop it right away. */ 652 shdr_info[cnt].idx = 0; 653 else 654 shdr_info[cnt].group_cnt = inner - 1; 655 } 656 else if (unlikely (shdr_info[cnt].shdr.sh_type == SHT_GNU_versym)) 657 { 658 assert (shdr_info[shdr_info[cnt].shdr.sh_link].version_idx == 0); 659 shdr_info[shdr_info[cnt].shdr.sh_link].version_idx = cnt; 660 } 661 662 /* If this section is part of a group make sure it is not 663 discarded right away. */ 664 if ((shdr_info[cnt].shdr.sh_flags & SHF_GROUP) != 0) 665 { 666 assert (shdr_info[cnt].group_idx != 0); 667 668 if (shdr_info[shdr_info[cnt].group_idx].idx == 0) 669 { 670 /* The section group section will be removed. */ 671 shdr_info[cnt].group_idx = 0; 672 shdr_info[cnt].shdr.sh_flags &= ~SHF_GROUP; 673 } 674 } 675 676 /* Increment the counter. */ 677 ++cnt; 678 } 679 680 /* Now determine which sections can go away. The general rule is that 681 all sections which are not used at runtime are stripped out. But 682 there are a few exceptions: 683 684 - special sections named ".comment" and ".note" are kept 685 - OS or architecture specific sections are kept since we might not 686 know how to handle them 687 - if a section is referred to from a section which is not removed 688 in the sh_link or sh_info element it cannot be removed either 689 */ 690 for (cnt = 1; cnt < shnum; ++cnt) 691 /* Check whether the section can be removed. */ 692 if (remove_shdrs ? !(shdr_info[cnt].shdr.sh_flags & SHF_ALLOC) 693 : ebl_section_strip_p (ebl, ehdr, &shdr_info[cnt].shdr, 694 shdr_info[cnt].name, remove_comment, 695 remove_debug)) 696 { 697 /* For now assume this section will be removed. */ 698 shdr_info[cnt].idx = 0; 699 700 idx = shdr_info[cnt].group_idx; 701 while (idx != 0) 702 { 703 /* The section group data is already loaded. */ 704 assert (shdr_info[idx].data != NULL); 705 706 /* If the references section group is a normal section 707 group and has one element remaining, or if it is an 708 empty COMDAT section group it is removed. */ 709 bool is_comdat = (((Elf32_Word *) shdr_info[idx].data->d_buf)[0] 710 & GRP_COMDAT) != 0; 711 712 --shdr_info[idx].group_cnt; 713 if ((!is_comdat && shdr_info[idx].group_cnt == 1) 714 || (is_comdat && shdr_info[idx].group_cnt == 0)) 715 { 716 shdr_info[idx].idx = 0; 717 /* Continue recursively. */ 718 idx = shdr_info[idx].group_idx; 719 } 720 else 721 break; 722 } 723 } 724 725 /* Mark the SHT_NULL section as handled. */ 726 shdr_info[0].idx = 2; 727 728 729 /* Handle exceptions: section groups and cross-references. We might 730 have to repeat this a few times since the resetting of the flag 731 might propagate. */ 732 do 733 { 734 changes = false; 735 736 for (cnt = 1; cnt < shnum; ++cnt) 737 { 738 if (shdr_info[cnt].idx == 0) 739 { 740 /* If a relocation section is marked as being removed make 741 sure the section it is relocating is removed, too. */ 742 if ((shdr_info[cnt].shdr.sh_type == SHT_REL 743 || shdr_info[cnt].shdr.sh_type == SHT_RELA) 744 && shdr_info[shdr_info[cnt].shdr.sh_info].idx != 0) 745 shdr_info[cnt].idx = 1; 746 747 /* If a group section is marked as being removed make 748 sure all the sections it contains are being removed, too. */ 749 if (shdr_info[cnt].shdr.sh_type == SHT_GROUP) 750 { 751 Elf32_Word *grpref; 752 grpref = (Elf32_Word *) shdr_info[cnt].data->d_buf; 753 for (size_t in = 1; 754 in < shdr_info[cnt].data->d_size / sizeof (Elf32_Word); 755 ++in) 756 if (shdr_info[grpref[in]].idx != 0) 757 { 758 shdr_info[cnt].idx = 1; 759 break; 760 } 761 } 762 } 763 764 if (shdr_info[cnt].idx == 1) 765 { 766 /* The content of symbol tables we don't remove must not 767 reference any section which we do remove. Otherwise 768 we cannot remove the section. */ 769 if (debug_fname != NULL 770 && shdr_info[cnt].debug_data == NULL 771 && (shdr_info[cnt].shdr.sh_type == SHT_DYNSYM 772 || shdr_info[cnt].shdr.sh_type == SHT_SYMTAB)) 773 { 774 /* Make sure the data is loaded. */ 775 if (shdr_info[cnt].data == NULL) 776 { 777 shdr_info[cnt].data 778 = elf_getdata (shdr_info[cnt].scn, NULL); 779 if (shdr_info[cnt].data == NULL) 780 INTERNAL_ERROR (fname); 781 } 782 Elf_Data *symdata = shdr_info[cnt].data; 783 784 /* If there is an extended section index table load it 785 as well. */ 786 if (shdr_info[cnt].symtab_idx != 0 787 && shdr_info[shdr_info[cnt].symtab_idx].data == NULL) 788 { 789 assert (shdr_info[cnt].shdr.sh_type == SHT_SYMTAB); 790 791 shdr_info[shdr_info[cnt].symtab_idx].data 792 = elf_getdata (shdr_info[shdr_info[cnt].symtab_idx].scn, 793 NULL); 794 if (shdr_info[shdr_info[cnt].symtab_idx].data == NULL) 795 INTERNAL_ERROR (fname); 796 } 797 Elf_Data *xndxdata 798 = shdr_info[shdr_info[cnt].symtab_idx].data; 799 800 /* Go through all symbols and make sure the section they 801 reference is not removed. */ 802 size_t elsize = gelf_fsize (elf, ELF_T_SYM, 1, 803 ehdr->e_version); 804 805 for (size_t inner = 0; 806 inner < shdr_info[cnt].data->d_size / elsize; 807 ++inner) 808 { 809 GElf_Sym sym_mem; 810 Elf32_Word xndx; 811 GElf_Sym *sym = gelf_getsymshndx (symdata, xndxdata, 812 inner, &sym_mem, 813 &xndx); 814 if (sym == NULL) 815 INTERNAL_ERROR (fname); 816 817 size_t scnidx = sym->st_shndx; 818 if (scnidx == SHN_UNDEF || scnidx >= shnum 819 || (scnidx >= SHN_LORESERVE 820 && scnidx <= SHN_HIRESERVE 821 && scnidx != SHN_XINDEX) 822 /* Don't count in the section symbols. */ 823 || GELF_ST_TYPE (sym->st_info) == STT_SECTION) 824 /* This is no section index, leave it alone. */ 825 continue; 826 else if (scnidx == SHN_XINDEX) 827 scnidx = xndx; 828 829 if (shdr_info[scnidx].idx == 0) 830 /* This symbol table has a real symbol in 831 a discarded section. So preserve the 832 original table in the debug file. */ 833 shdr_info[cnt].debug_data = symdata; 834 } 835 } 836 837 /* Cross referencing happens: 838 - for the cases the ELF specification says. That are 839 + SHT_DYNAMIC in sh_link to string table 840 + SHT_HASH in sh_link to symbol table 841 + SHT_REL and SHT_RELA in sh_link to symbol table 842 + SHT_SYMTAB and SHT_DYNSYM in sh_link to string table 843 + SHT_GROUP in sh_link to symbol table 844 + SHT_SYMTAB_SHNDX in sh_link to symbol table 845 Other (OS or architecture-specific) sections might as 846 well use this field so we process it unconditionally. 847 - references inside section groups 848 - specially marked references in sh_info if the SHF_INFO_LINK 849 flag is set 850 */ 851 852 if (shdr_info[shdr_info[cnt].shdr.sh_link].idx == 0) 853 { 854 shdr_info[shdr_info[cnt].shdr.sh_link].idx = 1; 855 changes |= shdr_info[cnt].shdr.sh_link < cnt; 856 } 857 858 /* Handle references through sh_info. */ 859 if (SH_INFO_LINK_P (&shdr_info[cnt].shdr) 860 && shdr_info[shdr_info[cnt].shdr.sh_info].idx == 0) 861 { 862 shdr_info[shdr_info[cnt].shdr.sh_info].idx = 1; 863 changes |= shdr_info[cnt].shdr.sh_info < cnt; 864 } 865 866 /* Mark the section as investigated. */ 867 shdr_info[cnt].idx = 2; 868 } 869 870 if (debug_fname != NULL 871 && (shdr_info[cnt].idx == 0 || shdr_info[cnt].debug_data != NULL)) 872 { 873 /* This section is being preserved in the debug file. 874 Sections it refers to must be preserved there too. 875 876 In this pass we mark sections to be preserved in both 877 files by setting the .debug_data pointer to the original 878 file's .data pointer. Below, we'll copy the section 879 contents. */ 880 881 inline void check_preserved (size_t i) 882 { 883 if (i != 0 && shdr_info[i].idx != 0 884 && shdr_info[i].debug_data == NULL) 885 { 886 if (shdr_info[i].data == NULL) 887 shdr_info[i].data = elf_getdata (shdr_info[i].scn, NULL); 888 if (shdr_info[i].data == NULL) 889 INTERNAL_ERROR (fname); 890 891 shdr_info[i].debug_data = shdr_info[i].data; 892 changes |= i < cnt; 893 } 894 } 895 896 check_preserved (shdr_info[cnt].shdr.sh_link); 897 if (SH_INFO_LINK_P (&shdr_info[cnt].shdr)) 898 check_preserved (shdr_info[cnt].shdr.sh_info); 899 } 900 } 901 } 902 while (changes); 903 904 /* Copy the removed sections to the debug output file. 905 The ones that are not removed in the stripped file are SHT_NOBITS. */ 906 if (debug_fname != NULL) 907 { 908 for (cnt = 1; cnt < shnum; ++cnt) 909 { 910 scn = elf_newscn (debugelf); 911 if (scn == NULL) 912 error (EXIT_FAILURE, 0, 913 gettext ("while generating output file: %s"), 914 elf_errmsg (-1)); 915 916 bool discard_section = (shdr_info[cnt].idx > 0 917 && shdr_info[cnt].debug_data == NULL 918 && shdr_info[cnt].shdr.sh_type != SHT_NOTE 919 && shdr_info[cnt].shdr.sh_type != SHT_GROUP 920 && cnt != ehdr->e_shstrndx); 921 922 /* Set the section header in the new file. */ 923 GElf_Shdr debugshdr = shdr_info[cnt].shdr; 924 if (discard_section) 925 debugshdr.sh_type = SHT_NOBITS; 926 927 if (unlikely (gelf_update_shdr (scn, &debugshdr) == 0)) 928 /* There cannot be any overflows. */ 929 INTERNAL_ERROR (fname); 930 931 /* Get the data from the old file if necessary. */ 932 if (shdr_info[cnt].data == NULL) 933 { 934 shdr_info[cnt].data = elf_getdata (shdr_info[cnt].scn, NULL); 935 if (shdr_info[cnt].data == NULL) 936 INTERNAL_ERROR (fname); 937 } 938 939 /* Set the data. This is done by copying from the old file. */ 940 Elf_Data *debugdata = elf_newdata (scn); 941 if (debugdata == NULL) 942 INTERNAL_ERROR (fname); 943 944 /* Copy the structure. This data may be modified in place 945 before we write out the file. */ 946 *debugdata = *shdr_info[cnt].data; 947 if (discard_section) 948 debugdata->d_buf = NULL; 949 else if (shdr_info[cnt].debug_data != NULL 950 || shdr_info[cnt].shdr.sh_type == SHT_GROUP) 951 { 952 /* Copy the original data before it gets modified. */ 953 shdr_info[cnt].debug_data = debugdata; 954 debugdata->d_buf = memcpy (xmalloc (debugdata->d_size), 955 debugdata->d_buf, debugdata->d_size); 956 } 957 } 958 959 /* Finish the ELF header. Fill in the fields not handled by 960 libelf from the old file. */ 961 debugehdr = gelf_getehdr (debugelf, &debugehdr_mem); 962 if (debugehdr == NULL) 963 INTERNAL_ERROR (fname); 964 965 memcpy (debugehdr->e_ident, ehdr->e_ident, EI_NIDENT); 966 debugehdr->e_type = ehdr->e_type; 967 debugehdr->e_machine = ehdr->e_machine; 968 debugehdr->e_version = ehdr->e_version; 969 debugehdr->e_entry = ehdr->e_entry; 970 debugehdr->e_flags = ehdr->e_flags; 971 debugehdr->e_shstrndx = ehdr->e_shstrndx; 972 973 if (unlikely (gelf_update_ehdr (debugelf, debugehdr) == 0)) 974 { 975 error (0, 0, gettext ("%s: error while creating ELF header: %s"), 976 debug_fname, elf_errmsg (-1)); 977 result = 1; 978 goto fail_close; 979 } 980 } 981 982 /* Mark the section header string table as unused, we will create 983 a new one. */ 984 shdr_info[shstrndx].idx = 0; 985 986 /* We need a string table for the section headers. */ 987 shst = ebl_strtabinit (true); 988 if (shst == NULL) 989 error (EXIT_FAILURE, errno, gettext ("while preparing output for '%s'"), 990 output_fname ?: fname); 991 992 /* Assign new section numbers. */ 993 shdr_info[0].idx = 0; 994 for (cnt = idx = 1; cnt < shnum; ++cnt) 995 if (shdr_info[cnt].idx > 0) 996 { 997 shdr_info[cnt].idx = idx++; 998 999 /* Create a new section. */ 1000 shdr_info[cnt].newscn = elf_newscn (newelf); 1001 if (shdr_info[cnt].newscn == NULL) 1002 error (EXIT_FAILURE, 0, gettext ("while generating output file: %s"), 1003 elf_errmsg (-1)); 1004 1005 assert (elf_ndxscn (shdr_info[cnt].newscn) == shdr_info[cnt].idx); 1006 1007 /* Add this name to the section header string table. */ 1008 shdr_info[cnt].se = ebl_strtabadd (shst, shdr_info[cnt].name, 0); 1009 } 1010 1011 /* Test whether we are doing anything at all. */ 1012 if (cnt == idx) 1013 /* Nope, all removable sections are already gone. */ 1014 goto fail_close; 1015 1016 /* Create the reference to the file with the debug info. */ 1017 if (debug_fname != NULL && !remove_shdrs) 1018 { 1019 /* Add the section header string table section name. */ 1020 shdr_info[cnt].se = ebl_strtabadd (shst, ".gnu_debuglink", 15); 1021 shdr_info[cnt].idx = idx++; 1022 1023 /* Create the section header. */ 1024 shdr_info[cnt].shdr.sh_type = SHT_PROGBITS; 1025 shdr_info[cnt].shdr.sh_flags = 0; 1026 shdr_info[cnt].shdr.sh_addr = 0; 1027 shdr_info[cnt].shdr.sh_link = SHN_UNDEF; 1028 shdr_info[cnt].shdr.sh_info = SHN_UNDEF; 1029 shdr_info[cnt].shdr.sh_entsize = 0; 1030 shdr_info[cnt].shdr.sh_addralign = 4; 1031 /* We set the offset to zero here. Before we write the ELF file the 1032 field must have the correct value. This is done in the final 1033 loop over all section. Then we have all the information needed. */ 1034 shdr_info[cnt].shdr.sh_offset = 0; 1035 1036 /* Create the section. */ 1037 shdr_info[cnt].newscn = elf_newscn (newelf); 1038 if (shdr_info[cnt].newscn == NULL) 1039 error (EXIT_FAILURE, 0, 1040 gettext ("while create section header section: %s"), 1041 elf_errmsg (-1)); 1042 assert (elf_ndxscn (shdr_info[cnt].newscn) == shdr_info[cnt].idx); 1043 1044 shdr_info[cnt].data = elf_newdata (shdr_info[cnt].newscn); 1045 if (shdr_info[cnt].data == NULL) 1046 error (EXIT_FAILURE, 0, gettext ("cannot allocate section data: %s"), 1047 elf_errmsg (-1)); 1048 1049 char *debug_basename = basename (debug_fname_embed ?: debug_fname); 1050 off_t crc_offset = strlen (debug_basename) + 1; 1051 /* Align to 4 byte boundary */ 1052 crc_offset = ((crc_offset - 1) & ~3) + 4; 1053 1054 shdr_info[cnt].data->d_align = 4; 1055 shdr_info[cnt].shdr.sh_size = shdr_info[cnt].data->d_size 1056 = crc_offset + 4; 1057 shdr_info[cnt].data->d_buf = xcalloc (1, shdr_info[cnt].data->d_size); 1058 1059 strcpy (shdr_info[cnt].data->d_buf, debug_basename); 1060 1061 /* Cache this Elf_Data describing the CRC32 word in the section. 1062 We'll fill this in when we have written the debug file. */ 1063 debuglink_crc_data = *shdr_info[cnt].data; 1064 debuglink_crc_data.d_buf = ((char *) debuglink_crc_data.d_buf 1065 + crc_offset); 1066 debuglink_crc_data.d_size = 4; 1067 1068 /* One more section done. */ 1069 ++cnt; 1070 } 1071 1072 /* Index of the section header table in the shdr_info array. */ 1073 shdridx = cnt; 1074 1075 /* Add the section header string table section name. */ 1076 shdr_info[cnt].se = ebl_strtabadd (shst, ".shstrtab", 10); 1077 shdr_info[cnt].idx = idx; 1078 1079 /* Create the section header. */ 1080 shdr_info[cnt].shdr.sh_type = SHT_STRTAB; 1081 shdr_info[cnt].shdr.sh_flags = 0; 1082 shdr_info[cnt].shdr.sh_addr = 0; 1083 shdr_info[cnt].shdr.sh_link = SHN_UNDEF; 1084 shdr_info[cnt].shdr.sh_info = SHN_UNDEF; 1085 shdr_info[cnt].shdr.sh_entsize = 0; 1086 /* We set the offset to zero here. Before we write the ELF file the 1087 field must have the correct value. This is done in the final 1088 loop over all section. Then we have all the information needed. */ 1089 shdr_info[cnt].shdr.sh_offset = 0; 1090 shdr_info[cnt].shdr.sh_addralign = 1; 1091 1092 /* Create the section. */ 1093 shdr_info[cnt].newscn = elf_newscn (newelf); 1094 if (shdr_info[cnt].newscn == NULL) 1095 error (EXIT_FAILURE, 0, 1096 gettext ("while create section header section: %s"), 1097 elf_errmsg (-1)); 1098 assert (elf_ndxscn (shdr_info[cnt].newscn) == idx); 1099 1100 /* Finalize the string table and fill in the correct indices in the 1101 section headers. */ 1102 shstrtab_data = elf_newdata (shdr_info[cnt].newscn); 1103 if (shstrtab_data == NULL) 1104 error (EXIT_FAILURE, 0, 1105 gettext ("while create section header string table: %s"), 1106 elf_errmsg (-1)); 1107 ebl_strtabfinalize (shst, shstrtab_data); 1108 1109 /* We have to set the section size. */ 1110 shdr_info[cnt].shdr.sh_size = shstrtab_data->d_size; 1111 1112 /* Update the section information. */ 1113 GElf_Off lastoffset = 0; 1114 for (cnt = 1; cnt <= shdridx; ++cnt) 1115 if (shdr_info[cnt].idx > 0) 1116 { 1117 Elf_Data *newdata; 1118 1119 scn = elf_getscn (newelf, shdr_info[cnt].idx); 1120 assert (scn != NULL); 1121 1122 /* Update the name. */ 1123 shdr_info[cnt].shdr.sh_name = ebl_strtaboffset (shdr_info[cnt].se); 1124 1125 /* Update the section header from the input file. Some fields 1126 might be section indeces which now have to be adjusted. */ 1127 if (shdr_info[cnt].shdr.sh_link != 0) 1128 shdr_info[cnt].shdr.sh_link = 1129 shdr_info[shdr_info[cnt].shdr.sh_link].idx; 1130 1131 if (shdr_info[cnt].shdr.sh_type == SHT_GROUP) 1132 { 1133 assert (shdr_info[cnt].data != NULL); 1134 1135 Elf32_Word *grpref = (Elf32_Word *) shdr_info[cnt].data->d_buf; 1136 for (size_t inner = 0; 1137 inner < shdr_info[cnt].data->d_size / sizeof (Elf32_Word); 1138 ++inner) 1139 grpref[inner] = shdr_info[grpref[inner]].idx; 1140 } 1141 1142 /* Handle the SHT_REL, SHT_RELA, and SHF_INFO_LINK flag. */ 1143 if (SH_INFO_LINK_P (&shdr_info[cnt].shdr)) 1144 shdr_info[cnt].shdr.sh_info = 1145 shdr_info[shdr_info[cnt].shdr.sh_info].idx; 1146 1147 /* Get the data from the old file if necessary. We already 1148 created the data for the section header string table. */ 1149 if (cnt < shnum) 1150 { 1151 if (shdr_info[cnt].data == NULL) 1152 { 1153 shdr_info[cnt].data = elf_getdata (shdr_info[cnt].scn, NULL); 1154 if (shdr_info[cnt].data == NULL) 1155 INTERNAL_ERROR (fname); 1156 } 1157 1158 /* Set the data. This is done by copying from the old file. */ 1159 newdata = elf_newdata (scn); 1160 if (newdata == NULL) 1161 INTERNAL_ERROR (fname); 1162 1163 /* Copy the structure. */ 1164 *newdata = *shdr_info[cnt].data; 1165 1166 /* We know the size. */ 1167 shdr_info[cnt].shdr.sh_size = shdr_info[cnt].data->d_size; 1168 1169 /* We have to adjust symbol tables. The st_shndx member might 1170 have to be updated. */ 1171 if (shdr_info[cnt].shdr.sh_type == SHT_DYNSYM 1172 || shdr_info[cnt].shdr.sh_type == SHT_SYMTAB) 1173 { 1174 Elf_Data *versiondata = NULL; 1175 Elf_Data *shndxdata = NULL; 1176 1177 size_t elsize = gelf_fsize (elf, ELF_T_SYM, 1, 1178 ehdr->e_version); 1179 1180 if (shdr_info[cnt].symtab_idx != 0) 1181 { 1182 assert (shdr_info[cnt].shdr.sh_type == SHT_SYMTAB_SHNDX); 1183 /* This section has extended section information. 1184 We have to modify that information, too. */ 1185 shndxdata = elf_getdata (shdr_info[shdr_info[cnt].symtab_idx].scn, 1186 NULL); 1187 1188 assert ((versiondata->d_size / sizeof (Elf32_Word)) 1189 >= shdr_info[cnt].data->d_size / elsize); 1190 } 1191 1192 if (shdr_info[cnt].version_idx != 0) 1193 { 1194 assert (shdr_info[cnt].shdr.sh_type == SHT_DYNSYM); 1195 /* This section has associated version 1196 information. We have to modify that 1197 information, too. */ 1198 versiondata = elf_getdata (shdr_info[shdr_info[cnt].version_idx].scn, 1199 NULL); 1200 1201 assert ((versiondata->d_size / sizeof (GElf_Versym)) 1202 >= shdr_info[cnt].data->d_size / elsize); 1203 } 1204 1205 shdr_info[cnt].newsymidx 1206 = (Elf32_Word *) xcalloc (shdr_info[cnt].data->d_size 1207 / elsize, sizeof (Elf32_Word)); 1208 1209 bool last_was_local = true; 1210 size_t destidx; 1211 size_t inner; 1212 for (destidx = inner = 1; 1213 inner < shdr_info[cnt].data->d_size / elsize; 1214 ++inner) 1215 { 1216 Elf32_Word sec; 1217 GElf_Sym sym_mem; 1218 Elf32_Word xshndx; 1219 GElf_Sym *sym = gelf_getsymshndx (shdr_info[cnt].data, 1220 shndxdata, inner, 1221 &sym_mem, &xshndx); 1222 if (sym == NULL) 1223 INTERNAL_ERROR (fname); 1224 1225 if (sym->st_shndx == SHN_UNDEF 1226 || (sym->st_shndx >= shnum 1227 && sym->st_shndx != SHN_XINDEX)) 1228 { 1229 /* This is no section index, leave it alone 1230 unless it is moved. */ 1231 if (destidx != inner 1232 && gelf_update_symshndx (shdr_info[cnt].data, 1233 shndxdata, 1234 destidx, sym, 1235 xshndx) == 0) 1236 INTERNAL_ERROR (fname); 1237 1238 shdr_info[cnt].newsymidx[inner] = destidx++; 1239 1240 if (last_was_local 1241 && GELF_ST_BIND (sym->st_info) != STB_LOCAL) 1242 { 1243 last_was_local = false; 1244 shdr_info[cnt].shdr.sh_info = destidx - 1; 1245 } 1246 1247 continue; 1248 } 1249 1250 /* Get the full section index, if necessary from the 1251 XINDEX table. */ 1252 if (sym->st_shndx != SHN_XINDEX) 1253 sec = shdr_info[sym->st_shndx].idx; 1254 else 1255 { 1256 assert (shndxdata != NULL); 1257 1258 sec = shdr_info[xshndx].idx; 1259 } 1260 1261 if (sec != 0) 1262 { 1263 GElf_Section nshndx; 1264 Elf32_Word nxshndx; 1265 1266 if (sec < SHN_LORESERVE) 1267 { 1268 nshndx = sec; 1269 nxshndx = 0; 1270 } 1271 else 1272 { 1273 nshndx = SHN_XINDEX; 1274 nxshndx = sec; 1275 } 1276 1277 assert (sec < SHN_LORESERVE || shndxdata != NULL); 1278 1279 if ((inner != destidx || nshndx != sym->st_shndx 1280 || (shndxdata != NULL && nxshndx != xshndx)) 1281 && (sym->st_shndx = nshndx, 1282 gelf_update_symshndx (shdr_info[cnt].data, 1283 shndxdata, 1284 destidx, sym, 1285 nxshndx) == 0)) 1286 INTERNAL_ERROR (fname); 1287 1288 shdr_info[cnt].newsymidx[inner] = destidx++; 1289 1290 if (last_was_local 1291 && GELF_ST_BIND (sym->st_info) != STB_LOCAL) 1292 { 1293 last_was_local = false; 1294 shdr_info[cnt].shdr.sh_info = destidx - 1; 1295 } 1296 } 1297 else if (debug_fname == NULL 1298 || shdr_info[cnt].debug_data == NULL) 1299 /* This is a section or group signature symbol 1300 for a section which has been removed. */ 1301 { 1302 size_t sidx = (sym->st_shndx != SHN_XINDEX 1303 ? sym->st_shndx : xshndx); 1304 assert (GELF_ST_TYPE (sym->st_info) == STT_SECTION 1305 || (shdr_info[sidx].shdr.sh_type == SHT_GROUP 1306 && shdr_info[sidx].shdr.sh_info == inner)); 1307 } 1308 } 1309 1310 if (destidx != inner) 1311 { 1312 /* The size of the symbol table changed. */ 1313 shdr_info[cnt].shdr.sh_size = newdata->d_size 1314 = destidx * elsize; 1315 any_symtab_changes = true; 1316 } 1317 else 1318 { 1319 /* The symbol table didn't really change. */ 1320 free (shdr_info[cnt].newsymidx); 1321 shdr_info[cnt].newsymidx = NULL; 1322 } 1323 } 1324 } 1325 1326 /* If we have to, compute the offset of the section. */ 1327 if (shdr_info[cnt].shdr.sh_offset == 0) 1328 shdr_info[cnt].shdr.sh_offset 1329 = ((lastoffset + shdr_info[cnt].shdr.sh_addralign - 1) 1330 & ~((GElf_Off) (shdr_info[cnt].shdr.sh_addralign - 1))); 1331 1332 /* Set the section header in the new file. */ 1333 if (unlikely (gelf_update_shdr (scn, &shdr_info[cnt].shdr) == 0)) 1334 /* There cannot be any overflows. */ 1335 INTERNAL_ERROR (fname); 1336 1337 /* Remember the last section written so far. */ 1338 GElf_Off filesz = (shdr_info[cnt].shdr.sh_type != SHT_NOBITS 1339 ? shdr_info[cnt].shdr.sh_size : 0); 1340 if (lastoffset < shdr_info[cnt].shdr.sh_offset + filesz) 1341 lastoffset = shdr_info[cnt].shdr.sh_offset + filesz; 1342 } 1343 1344 /* Adjust symbol references if symbol tables changed. */ 1345 if (any_symtab_changes) 1346 /* Find all relocation sections which use this symbol table. */ 1347 for (cnt = 1; cnt <= shdridx; ++cnt) 1348 { 1349 /* Update section headers when the data size has changed. 1350 We also update the SHT_NOBITS section in the debug 1351 file so that the section headers match in sh_size. */ 1352 inline void update_section_size (const Elf_Data *newdata) 1353 { 1354 GElf_Shdr shdr_mem; 1355 GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem); 1356 shdr->sh_size = newdata->d_size; 1357 (void) gelf_update_shdr (scn, shdr); 1358 if (debugelf != NULL) 1359 { 1360 /* libelf will use d_size to set sh_size. */ 1361 Elf_Data *debugdata = elf_getdata (elf_getscn (debugelf, 1362 cnt), NULL); 1363 debugdata->d_size = newdata->d_size; 1364 } 1365 } 1366 1367 if (shdr_info[cnt].idx == 0 && debug_fname == NULL) 1368 /* Ignore sections which are discarded. When we are saving a 1369 relocation section in a separate debug file, we must fix up 1370 the symbol table references. */ 1371 continue; 1372 1373 const Elf32_Word symtabidx = shdr_info[cnt].old_sh_link; 1374 const Elf32_Word *const newsymidx = shdr_info[symtabidx].newsymidx; 1375 switch (shdr_info[cnt].shdr.sh_type) 1376 { 1377 inline bool no_symtab_updates (void) 1378 { 1379 /* If the symbol table hasn't changed, do not do anything. */ 1380 if (shdr_info[symtabidx].newsymidx == NULL) 1381 return true; 1382 1383 /* If the symbol table is not discarded, but additionally 1384 duplicated in the separate debug file and this section 1385 is discarded, don't adjust anything. */ 1386 return (shdr_info[cnt].idx == 0 1387 && shdr_info[symtabidx].debug_data != NULL); 1388 } 1389 1390 case SHT_REL: 1391 case SHT_RELA: 1392 if (no_symtab_updates ()) 1393 break; 1394 1395 Elf_Data *d = elf_getdata (shdr_info[cnt].idx == 0 1396 ? elf_getscn (debugelf, cnt) 1397 : elf_getscn (newelf, 1398 shdr_info[cnt].idx), 1399 NULL); 1400 assert (d != NULL); 1401 size_t nrels = (shdr_info[cnt].shdr.sh_size 1402 / shdr_info[cnt].shdr.sh_entsize); 1403 1404 if (shdr_info[cnt].shdr.sh_type == SHT_REL) 1405 for (size_t relidx = 0; relidx < nrels; ++relidx) 1406 { 1407 GElf_Rel rel_mem; 1408 if (gelf_getrel (d, relidx, &rel_mem) == NULL) 1409 INTERNAL_ERROR (fname); 1410 1411 size_t symidx = GELF_R_SYM (rel_mem.r_info); 1412 if (newsymidx[symidx] != symidx) 1413 { 1414 rel_mem.r_info 1415 = GELF_R_INFO (newsymidx[symidx], 1416 GELF_R_TYPE (rel_mem.r_info)); 1417 1418 if (gelf_update_rel (d, relidx, &rel_mem) == 0) 1419 INTERNAL_ERROR (fname); 1420 } 1421 } 1422 else 1423 for (size_t relidx = 0; relidx < nrels; ++relidx) 1424 { 1425 GElf_Rela rel_mem; 1426 if (gelf_getrela (d, relidx, &rel_mem) == NULL) 1427 INTERNAL_ERROR (fname); 1428 1429 size_t symidx = GELF_R_SYM (rel_mem.r_info); 1430 if (newsymidx[symidx] != symidx) 1431 { 1432 rel_mem.r_info 1433 = GELF_R_INFO (newsymidx[symidx], 1434 GELF_R_TYPE (rel_mem.r_info)); 1435 1436 if (gelf_update_rela (d, relidx, &rel_mem) == 0) 1437 INTERNAL_ERROR (fname); 1438 } 1439 } 1440 break; 1441 1442 case SHT_HASH: 1443 if (no_symtab_updates ()) 1444 break; 1445 1446 /* We have to recompute the hash table. */ 1447 1448 assert (shdr_info[cnt].idx > 0); 1449 1450 /* The hash section in the new file. */ 1451 scn = elf_getscn (newelf, shdr_info[cnt].idx); 1452 1453 /* The symbol table data. */ 1454 Elf_Data *symd = elf_getdata (elf_getscn (newelf, 1455 shdr_info[symtabidx].idx), 1456 NULL); 1457 assert (symd != NULL); 1458 1459 /* The hash table data. */ 1460 Elf_Data *hashd = elf_getdata (scn, NULL); 1461 assert (hashd != NULL); 1462 1463 if (shdr_info[cnt].shdr.sh_entsize == sizeof (Elf32_Word)) 1464 { 1465 /* Sane arches first. */ 1466 Elf32_Word *bucket = (Elf32_Word *) hashd->d_buf; 1467 1468 size_t strshndx = shdr_info[symtabidx].old_sh_link; 1469 size_t elsize = gelf_fsize (elf, ELF_T_SYM, 1, 1470 ehdr->e_version); 1471 1472 /* Adjust the nchain value. The symbol table size 1473 changed. We keep the same size for the bucket array. */ 1474 bucket[1] = symd->d_size / elsize; 1475 Elf32_Word nbucket = bucket[0]; 1476 bucket += 2; 1477 Elf32_Word *chain = bucket + nbucket; 1478 1479 /* New size of the section. */ 1480 hashd->d_size = ((2 + symd->d_size / elsize + nbucket) 1481 * sizeof (Elf32_Word)); 1482 update_section_size (hashd); 1483 1484 /* Clear the arrays. */ 1485 memset (bucket, '\0', 1486 (symd->d_size / elsize + nbucket) 1487 * sizeof (Elf32_Word)); 1488 1489 for (size_t inner = shdr_info[symtabidx].shdr.sh_info; 1490 inner < symd->d_size / elsize; ++inner) 1491 { 1492 GElf_Sym sym_mem; 1493 GElf_Sym *sym = gelf_getsym (symd, inner, &sym_mem); 1494 assert (sym != NULL); 1495 1496 const char *name = elf_strptr (elf, strshndx, 1497 sym->st_name); 1498 assert (name != NULL); 1499 size_t hidx = elf_hash (name) % nbucket; 1500 1501 if (bucket[hidx] == 0) 1502 bucket[hidx] = inner; 1503 else 1504 { 1505 hidx = bucket[hidx]; 1506 1507 while (chain[hidx] != 0) 1508 hidx = chain[hidx]; 1509 1510 chain[hidx] = inner; 1511 } 1512 } 1513 } 1514 else 1515 { 1516 /* Alpha and S390 64-bit use 64-bit SHT_HASH entries. */ 1517 assert (shdr_info[cnt].shdr.sh_entsize 1518 == sizeof (Elf64_Xword)); 1519 1520 Elf64_Xword *bucket = (Elf64_Xword *) hashd->d_buf; 1521 1522 size_t strshndx = shdr_info[symtabidx].old_sh_link; 1523 size_t elsize = gelf_fsize (elf, ELF_T_SYM, 1, 1524 ehdr->e_version); 1525 1526 /* Adjust the nchain value. The symbol table size 1527 changed. We keep the same size for the bucket array. */ 1528 bucket[1] = symd->d_size / elsize; 1529 Elf64_Xword nbucket = bucket[0]; 1530 bucket += 2; 1531 Elf64_Xword *chain = bucket + nbucket; 1532 1533 /* New size of the section. */ 1534 hashd->d_size = ((2 + symd->d_size / elsize + nbucket) 1535 * sizeof (Elf64_Xword)); 1536 update_section_size (hashd); 1537 1538 /* Clear the arrays. */ 1539 memset (bucket, '\0', 1540 (symd->d_size / elsize + nbucket) 1541 * sizeof (Elf64_Xword)); 1542 1543 for (size_t inner = shdr_info[symtabidx].shdr.sh_info; 1544 inner < symd->d_size / elsize; ++inner) 1545 { 1546 GElf_Sym sym_mem; 1547 GElf_Sym *sym = gelf_getsym (symd, inner, &sym_mem); 1548 assert (sym != NULL); 1549 1550 const char *name = elf_strptr (elf, strshndx, 1551 sym->st_name); 1552 assert (name != NULL); 1553 size_t hidx = elf_hash (name) % nbucket; 1554 1555 if (bucket[hidx] == 0) 1556 bucket[hidx] = inner; 1557 else 1558 { 1559 hidx = bucket[hidx]; 1560 1561 while (chain[hidx] != 0) 1562 hidx = chain[hidx]; 1563 1564 chain[hidx] = inner; 1565 } 1566 } 1567 } 1568 break; 1569 1570 case SHT_GNU_versym: 1571 /* If the symbol table changed we have to adjust the entries. */ 1572 if (no_symtab_updates ()) 1573 break; 1574 1575 assert (shdr_info[cnt].idx > 0); 1576 1577 /* The symbol version section in the new file. */ 1578 scn = elf_getscn (newelf, shdr_info[cnt].idx); 1579 1580 /* The symbol table data. */ 1581 symd = elf_getdata (elf_getscn (newelf, shdr_info[symtabidx].idx), 1582 NULL); 1583 assert (symd != NULL); 1584 1585 /* The version symbol data. */ 1586 Elf_Data *verd = elf_getdata (scn, NULL); 1587 assert (verd != NULL); 1588 1589 /* The symbol version array. */ 1590 GElf_Half *verstab = (GElf_Half *) verd->d_buf; 1591 1592 /* Walk through the list and */ 1593 size_t elsize = gelf_fsize (elf, verd->d_type, 1, 1594 ehdr->e_version); 1595 for (size_t inner = 1; inner < verd->d_size / elsize; ++inner) 1596 if (newsymidx[inner] != 0) 1597 /* Overwriting the same array works since the 1598 reordering can only move entries to lower indices 1599 in the array. */ 1600 verstab[newsymidx[inner]] = verstab[inner]; 1601 1602 /* New size of the section. */ 1603 verd->d_size = gelf_fsize (newelf, verd->d_type, 1604 symd->d_size 1605 / gelf_fsize (elf, symd->d_type, 1, 1606 ehdr->e_version), 1607 ehdr->e_version); 1608 update_section_size (verd); 1609 break; 1610 1611 case SHT_GROUP: 1612 if (no_symtab_updates ()) 1613 break; 1614 1615 /* Yes, the symbol table changed. 1616 Update the section header of the section group. */ 1617 scn = elf_getscn (newelf, shdr_info[cnt].idx); 1618 GElf_Shdr shdr_mem; 1619 GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem); 1620 assert (shdr != NULL); 1621 1622 shdr->sh_info = newsymidx[shdr->sh_info]; 1623 1624 (void) gelf_update_shdr (scn, shdr); 1625 break; 1626 } 1627 } 1628 1629 /* Remove any relocations between debug sections in ET_REL 1630 for the debug file when requested. These relocations are always 1631 zero based between the unallocated sections. */ 1632 if (debug_fname != NULL && reloc_debug && ehdr->e_type == ET_REL) 1633 { 1634 scn = NULL; 1635 cnt = 0; 1636 while ((scn = elf_nextscn (debugelf, scn)) != NULL) 1637 { 1638 cnt++; 1639 /* We need the actual section and header from the debugelf 1640 not just the cached original in shdr_info because we 1641 might want to change the size. */ 1642 GElf_Shdr shdr_mem; 1643 GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem); 1644 if (shdr->sh_type == SHT_REL || shdr->sh_type == SHT_RELA) 1645 { 1646 /* Make sure that this relocation section points to a 1647 section to relocate with contents, that isn't 1648 allocated and that is a debug section. */ 1649 Elf_Scn *tscn = elf_getscn (debugelf, shdr->sh_info); 1650 GElf_Shdr tshdr_mem; 1651 GElf_Shdr *tshdr = gelf_getshdr (tscn, &tshdr_mem); 1652 if (tshdr->sh_type == SHT_NOBITS 1653 || tshdr->sh_size == 0 1654 || (tshdr->sh_flags & SHF_ALLOC) != 0) 1655 continue; 1656 1657 const char *tname = elf_strptr (debugelf, shstrndx, 1658 tshdr->sh_name); 1659 if (! tname || ! ebl_debugscn_p (ebl, tname)) 1660 continue; 1661 1662 /* OK, lets relocate all trivial cross debug section 1663 relocations. */ 1664 Elf_Data *reldata = elf_getdata (scn, NULL); 1665 /* We actually wanted the rawdata, but since we already 1666 accessed it earlier as elf_getdata () that won't 1667 work. But debug sections are all ELF_T_BYTE, so it 1668 doesn't really matter. */ 1669 Elf_Data *tdata = elf_getdata (tscn, NULL); 1670 if (tdata->d_type != ELF_T_BYTE) 1671 INTERNAL_ERROR (fname); 1672 1673 /* Pick up the symbol table and shndx table to 1674 resolve relocation symbol indexes. */ 1675 Elf64_Word symt = shdr->sh_link; 1676 Elf_Data *symdata, *xndxdata; 1677 symdata = (shdr_info[symt].debug_data 1678 ?: shdr_info[symt].data); 1679 xndxdata = (shdr_info[shdr_info[symt].symtab_idx].debug_data 1680 ?: shdr_info[shdr_info[symt].symtab_idx].data); 1681 1682 /* Apply one relocation. Returns true when trivial 1683 relocation actually done. */ 1684 bool relocate (GElf_Addr offset, const GElf_Sxword addend, 1685 bool is_rela, int rtype, int symndx) 1686 { 1687 /* R_*_NONE relocs can always just be removed. */ 1688 if (rtype == 0) 1689 return true; 1690 1691 /* We only do simple absolute relocations. */ 1692 Elf_Type type = ebl_reloc_simple_type (ebl, rtype); 1693 if (type == ELF_T_NUM) 1694 return false; 1695 1696 /* These are the types we can relocate. */ 1697 #define TYPES DO_TYPE (BYTE, Byte); DO_TYPE (HALF, Half); \ 1698 DO_TYPE (WORD, Word); DO_TYPE (SWORD, Sword); \ 1699 DO_TYPE (XWORD, Xword); DO_TYPE (SXWORD, Sxword) 1700 1701 /* And only for relocations against other debug sections. */ 1702 GElf_Sym sym_mem; 1703 Elf32_Word xndx; 1704 GElf_Sym *sym = gelf_getsymshndx (symdata, xndxdata, 1705 symndx, &sym_mem, 1706 &xndx); 1707 Elf32_Word sec = (sym->st_shndx == SHN_XINDEX 1708 ? xndx : sym->st_shndx); 1709 if (ebl_debugscn_p (ebl, shdr_info[sec].name)) 1710 { 1711 size_t size; 1712 1713 #define DO_TYPE(NAME, Name) GElf_##Name Name; 1714 union { TYPES; } tmpbuf; 1715 #undef DO_TYPE 1716 1717 switch (type) 1718 { 1719 #define DO_TYPE(NAME, Name) \ 1720 case ELF_T_##NAME: \ 1721 size = sizeof (GElf_##Name); \ 1722 tmpbuf.Name = 0; \ 1723 break; 1724 TYPES; 1725 #undef DO_TYPE 1726 default: 1727 return false; 1728 } 1729 1730 if (offset > tdata->d_size 1731 || tdata->d_size - offset < size) 1732 error (0, 0, gettext ("bad relocation")); 1733 1734 /* When the symbol value is zero then for SHT_REL 1735 sections this is all that needs to be checked. 1736 The addend is contained in the original data at 1737 the offset already. So if the (section) symbol 1738 address is zero and the given addend is zero 1739 just remove the relocation, it isn't needed 1740 anymore. */ 1741 if (addend == 0 && sym->st_value == 0) 1742 return true; 1743 1744 Elf_Data tmpdata = 1745 { 1746 .d_type = type, 1747 .d_buf = &tmpbuf, 1748 .d_size = size, 1749 .d_version = EV_CURRENT, 1750 }; 1751 Elf_Data rdata = 1752 { 1753 .d_type = type, 1754 .d_buf = tdata->d_buf + offset, 1755 .d_size = size, 1756 .d_version = EV_CURRENT, 1757 }; 1758 1759 GElf_Addr value = sym->st_value; 1760 if (is_rela) 1761 { 1762 /* For SHT_RELA sections we just take the 1763 given addend and add it to the value. */ 1764 value += addend; 1765 } 1766 else 1767 { 1768 /* For SHT_REL sections we have to peek at 1769 what is already in the section at the given 1770 offset to get the addend. */ 1771 Elf_Data *d = gelf_xlatetom (debugelf, &tmpdata, 1772 &rdata, 1773 ehdr->e_ident[EI_DATA]); 1774 if (d == NULL) 1775 INTERNAL_ERROR (fname); 1776 assert (d == &tmpdata); 1777 } 1778 1779 switch (type) 1780 { 1781 #define DO_TYPE(NAME, Name) \ 1782 case ELF_T_##NAME: \ 1783 tmpbuf.Name += (GElf_##Name) value; \ 1784 break; 1785 TYPES; 1786 #undef DO_TYPE 1787 default: 1788 abort (); 1789 } 1790 1791 /* Now finally put in the new value. */ 1792 Elf_Data *s = gelf_xlatetof (debugelf, &rdata, 1793 &tmpdata, 1794 ehdr->e_ident[EI_DATA]); 1795 if (s == NULL) 1796 INTERNAL_ERROR (fname); 1797 assert (s == &rdata); 1798 1799 return true; 1800 } 1801 return false; 1802 } 1803 1804 size_t nrels = shdr->sh_size / shdr->sh_entsize; 1805 size_t next = 0; 1806 if (shdr->sh_type == SHT_REL) 1807 for (size_t relidx = 0; relidx < nrels; ++relidx) 1808 { 1809 GElf_Rel rel_mem; 1810 GElf_Rel *r = gelf_getrel (reldata, relidx, &rel_mem); 1811 if (! relocate (r->r_offset, 0, false, 1812 GELF_R_TYPE (r->r_info), 1813 GELF_R_SYM (r->r_info))) 1814 { 1815 if (relidx != next) 1816 gelf_update_rel (reldata, next, r); 1817 ++next; 1818 } 1819 } 1820 else 1821 for (size_t relidx = 0; relidx < nrels; ++relidx) 1822 { 1823 GElf_Rela rela_mem; 1824 GElf_Rela *r = gelf_getrela (reldata, relidx, &rela_mem); 1825 if (! relocate (r->r_offset, r->r_addend, true, 1826 GELF_R_TYPE (r->r_info), 1827 GELF_R_SYM (r->r_info))) 1828 { 1829 if (relidx != next) 1830 gelf_update_rela (reldata, next, r); 1831 ++next; 1832 } 1833 } 1834 1835 nrels = next; 1836 shdr->sh_size = reldata->d_size = nrels * shdr->sh_entsize; 1837 gelf_update_shdr (scn, shdr); 1838 } 1839 } 1840 } 1841 1842 /* Now that we have done all adjustments to the data, 1843 we can actually write out the debug file. */ 1844 if (debug_fname != NULL) 1845 { 1846 /* Finally write the file. */ 1847 if (unlikely (elf_update (debugelf, ELF_C_WRITE) == -1)) 1848 { 1849 error (0, 0, gettext ("while writing '%s': %s"), 1850 debug_fname, elf_errmsg (-1)); 1851 result = 1; 1852 goto fail_close; 1853 } 1854 1855 /* Create the real output file. First rename, then change the 1856 mode. */ 1857 if (rename (tmp_debug_fname, debug_fname) != 0 1858 || fchmod (debug_fd, mode) != 0) 1859 { 1860 error (0, errno, gettext ("while creating '%s'"), debug_fname); 1861 result = 1; 1862 goto fail_close; 1863 } 1864 1865 /* The temporary file does not exist anymore. */ 1866 tmp_debug_fname = NULL; 1867 1868 if (!remove_shdrs) 1869 { 1870 uint32_t debug_crc; 1871 Elf_Data debug_crc_data = 1872 { 1873 .d_type = ELF_T_WORD, 1874 .d_buf = &debug_crc, 1875 .d_size = sizeof (debug_crc), 1876 .d_version = EV_CURRENT 1877 }; 1878 1879 /* Compute the checksum which we will add to the executable. */ 1880 if (crc32_file (debug_fd, &debug_crc) != 0) 1881 { 1882 error (0, errno, gettext ("\ 1883 while computing checksum for debug information")); 1884 unlink (debug_fname); 1885 result = 1; 1886 goto fail_close; 1887 } 1888 1889 /* Store it in the debuglink section data. */ 1890 if (unlikely (gelf_xlatetof (newelf, &debuglink_crc_data, 1891 &debug_crc_data, ehdr->e_ident[EI_DATA]) 1892 != &debuglink_crc_data)) 1893 INTERNAL_ERROR (fname); 1894 } 1895 } 1896 1897 /* Finally finish the ELF header. Fill in the fields not handled by 1898 libelf from the old file. */ 1899 newehdr = gelf_getehdr (newelf, &newehdr_mem); 1900 if (newehdr == NULL) 1901 INTERNAL_ERROR (fname); 1902 1903 memcpy (newehdr->e_ident, ehdr->e_ident, EI_NIDENT); 1904 newehdr->e_type = ehdr->e_type; 1905 newehdr->e_machine = ehdr->e_machine; 1906 newehdr->e_version = ehdr->e_version; 1907 newehdr->e_entry = ehdr->e_entry; 1908 newehdr->e_flags = ehdr->e_flags; 1909 newehdr->e_phoff = ehdr->e_phoff; 1910 1911 /* We need to position the section header table. */ 1912 const size_t offsize = gelf_fsize (elf, ELF_T_OFF, 1, EV_CURRENT); 1913 newehdr->e_shoff = ((shdr_info[shdridx].shdr.sh_offset 1914 + shdr_info[shdridx].shdr.sh_size + offsize - 1) 1915 & ~((GElf_Off) (offsize - 1))); 1916 newehdr->e_shentsize = gelf_fsize (elf, ELF_T_SHDR, 1, EV_CURRENT); 1917 1918 /* The new section header string table index. */ 1919 if (likely (idx < SHN_HIRESERVE) && likely (idx != SHN_XINDEX)) 1920 newehdr->e_shstrndx = idx; 1921 else 1922 { 1923 /* The index does not fit in the ELF header field. */ 1924 shdr_info[0].scn = elf_getscn (elf, 0); 1925 1926 if (gelf_getshdr (shdr_info[0].scn, &shdr_info[0].shdr) == NULL) 1927 INTERNAL_ERROR (fname); 1928 1929 shdr_info[0].shdr.sh_link = idx; 1930 (void) gelf_update_shdr (shdr_info[0].scn, &shdr_info[0].shdr); 1931 1932 newehdr->e_shstrndx = SHN_XINDEX; 1933 } 1934 1935 if (gelf_update_ehdr (newelf, newehdr) == 0) 1936 { 1937 error (0, 0, gettext ("%s: error while creating ELF header: %s"), 1938 fname, elf_errmsg (-1)); 1939 return 1; 1940 } 1941 1942 /* We have everything from the old file. */ 1943 if (elf_cntl (elf, ELF_C_FDDONE) != 0) 1944 { 1945 error (0, 0, gettext ("%s: error while reading the file: %s"), 1946 fname, elf_errmsg (-1)); 1947 return 1; 1948 } 1949 1950 /* The ELF library better follows our layout when this is not a 1951 relocatable object file. */ 1952 elf_flagelf (newelf, ELF_C_SET, 1953 (ehdr->e_type != ET_REL ? ELF_F_LAYOUT : 0) 1954 | (permissive ? ELF_F_PERMISSIVE : 0)); 1955 1956 /* Finally write the file. */ 1957 if (elf_update (newelf, ELF_C_WRITE) == -1) 1958 { 1959 error (0, 0, gettext ("while writing '%s': %s"), 1960 fname, elf_errmsg (-1)); 1961 result = 1; 1962 } 1963 1964 if (remove_shdrs) 1965 { 1966 /* libelf can't cope without the section headers being properly intact. 1967 So we just let it write them normally, and then we nuke them later. */ 1968 1969 if (newehdr->e_ident[EI_CLASS] == ELFCLASS32) 1970 { 1971 assert (offsetof (Elf32_Ehdr, e_shentsize) + sizeof (Elf32_Half) 1972 == offsetof (Elf32_Ehdr, e_shnum)); 1973 assert (offsetof (Elf32_Ehdr, e_shnum) + sizeof (Elf32_Half) 1974 == offsetof (Elf32_Ehdr, e_shstrndx)); 1975 const Elf32_Off zero_off = 0; 1976 const Elf32_Half zero[3] = { 0, 0, SHN_UNDEF }; 1977 if (pwrite_retry (fd, &zero_off, sizeof zero_off, 1978 offsetof (Elf32_Ehdr, e_shoff)) != sizeof zero_off 1979 || (pwrite_retry (fd, zero, sizeof zero, 1980 offsetof (Elf32_Ehdr, e_shentsize)) 1981 != sizeof zero) 1982 || ftruncate64 (fd, shdr_info[shdridx].shdr.sh_offset) < 0) 1983 { 1984 error (0, errno, gettext ("while writing '%s'"), 1985 fname); 1986 result = 1; 1987 } 1988 } 1989 else 1990 { 1991 assert (offsetof (Elf64_Ehdr, e_shentsize) + sizeof (Elf64_Half) 1992 == offsetof (Elf64_Ehdr, e_shnum)); 1993 assert (offsetof (Elf64_Ehdr, e_shnum) + sizeof (Elf64_Half) 1994 == offsetof (Elf64_Ehdr, e_shstrndx)); 1995 const Elf64_Off zero_off = 0; 1996 const Elf64_Half zero[3] = { 0, 0, SHN_UNDEF }; 1997 if (pwrite_retry (fd, &zero_off, sizeof zero_off, 1998 offsetof (Elf64_Ehdr, e_shoff)) != sizeof zero_off 1999 || (pwrite_retry (fd, zero, sizeof zero, 2000 offsetof (Elf64_Ehdr, e_shentsize)) 2001 != sizeof zero) 2002 || ftruncate64 (fd, shdr_info[shdridx].shdr.sh_offset) < 0) 2003 { 2004 error (0, errno, gettext ("while writing '%s'"), 2005 fname); 2006 result = 1; 2007 } 2008 } 2009 } 2010 2011 fail_close: 2012 if (shdr_info != NULL) 2013 { 2014 /* For some sections we might have created an table to map symbol 2015 table indices. */ 2016 if (any_symtab_changes) 2017 for (cnt = 1; cnt <= shdridx; ++cnt) 2018 { 2019 free (shdr_info[cnt].newsymidx); 2020 if (shdr_info[cnt].debug_data != NULL) 2021 free (shdr_info[cnt].debug_data->d_buf); 2022 } 2023 2024 /* Free the memory. */ 2025 if ((shnum + 2) * sizeof (struct shdr_info) > MAX_STACK_ALLOC) 2026 free (shdr_info); 2027 } 2028 2029 /* Free other resources. */ 2030 if (shstrtab_data != NULL) 2031 free (shstrtab_data->d_buf); 2032 if (shst != NULL) 2033 ebl_strtabfree (shst); 2034 2035 /* That was it. Close the descriptors. */ 2036 if (elf_end (newelf) != 0) 2037 { 2038 error (0, 0, gettext ("error while finishing '%s': %s"), fname, 2039 elf_errmsg (-1)); 2040 result = 1; 2041 } 2042 2043 if (debugelf != NULL && elf_end (debugelf) != 0) 2044 { 2045 error (0, 0, gettext ("error while finishing '%s': %s"), debug_fname, 2046 elf_errmsg (-1)); 2047 result = 1; 2048 } 2049 2050 fail: 2051 /* Close the EBL backend. */ 2052 if (ebl != NULL) 2053 ebl_closebackend (ebl); 2054 2055 /* Close debug file descriptor, if opened */ 2056 if (debug_fd >= 0) 2057 { 2058 if (tmp_debug_fname != NULL) 2059 unlink (tmp_debug_fname); 2060 close (debug_fd); 2061 } 2062 2063 /* If requested, preserve the timestamp. */ 2064 if (tvp != NULL) 2065 { 2066 if (futimes (fd, tvp) != 0) 2067 { 2068 error (0, errno, gettext ("\ 2069 cannot set access and modification date of '%s'"), 2070 output_fname ?: fname); 2071 result = 1; 2072 } 2073 } 2074 2075 /* Close the file descriptor if we created a new file. */ 2076 if (output_fname != NULL) 2077 close (fd); 2078 2079 return result; 2080 } 2081 2082 2083 static int 2084 handle_ar (int fd, Elf *elf, const char *prefix, const char *fname, 2085 struct timeval tvp[2]) 2086 { 2087 size_t prefix_len = prefix == NULL ? 0 : strlen (prefix); 2088 size_t fname_len = strlen (fname) + 1; 2089 char new_prefix[prefix_len + 1 + fname_len]; 2090 char *cp = new_prefix; 2091 2092 /* Create the full name of the file. */ 2093 if (prefix != NULL) 2094 { 2095 cp = mempcpy (cp, prefix, prefix_len); 2096 *cp++ = ':'; 2097 } 2098 memcpy (cp, fname, fname_len); 2099 2100 2101 /* Process all the files contained in the archive. */ 2102 Elf *subelf; 2103 Elf_Cmd cmd = ELF_C_RDWR; 2104 int result = 0; 2105 while ((subelf = elf_begin (fd, cmd, elf)) != NULL) 2106 { 2107 /* The the header for this element. */ 2108 Elf_Arhdr *arhdr = elf_getarhdr (subelf); 2109 2110 if (elf_kind (subelf) == ELF_K_ELF) 2111 result |= handle_elf (fd, subelf, new_prefix, arhdr->ar_name, 0, NULL); 2112 else if (elf_kind (subelf) == ELF_K_AR) 2113 result |= handle_ar (fd, subelf, new_prefix, arhdr->ar_name, NULL); 2114 2115 /* Get next archive element. */ 2116 cmd = elf_next (subelf); 2117 if (unlikely (elf_end (subelf) != 0)) 2118 INTERNAL_ERROR (fname); 2119 } 2120 2121 if (tvp != NULL) 2122 { 2123 if (unlikely (futimes (fd, tvp) != 0)) 2124 { 2125 error (0, errno, gettext ("\ 2126 cannot set access and modification date of '%s'"), fname); 2127 result = 1; 2128 } 2129 } 2130 2131 if (unlikely (close (fd) != 0)) 2132 error (EXIT_FAILURE, errno, gettext ("while closing '%s'"), fname); 2133 2134 return result; 2135 } 2136 2137 2138 #include "debugpred.h" 2139
