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