1 /* Discard section not used at runtime from object files. 2 Copyright (C) 2000,2001,2002,2003,2004,2005,2006,2007,2008 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/time.h> 50 51 #include <elf-knowledge.h> 52 #include <libebl.h> 53 #include <system.h> 54 55 56 /* Name and version of program. */ 57 static void print_version (FILE *stream, struct argp_state *state); 58 void (*argp_program_version_hook) (FILE *, struct argp_state *) = print_version; 59 60 /* Bug report address. */ 61 const char *argp_program_bug_address = PACKAGE_BUGREPORT; 62 63 64 /* Values for the parameters which have no short form. */ 65 #define OPT_REMOVE_COMMENT 0x100 66 #define OPT_PERMISSIVE 0x101 67 68 69 /* Definitions of arguments for argp functions. */ 70 static const struct argp_option options[] = 71 { 72 { NULL, 0, NULL, 0, N_("Output selection:"), 0 }, 73 { "output", 'o', "FILE", 0, N_("Place stripped output into FILE"), 0 }, 74 { NULL, 'f', "FILE", 0, N_("Extract the removed sections into FILE"), 0 }, 75 { NULL, 'F', "FILE", 0, N_("Embed name FILE instead of -f argument"), 0 }, 76 77 { NULL, 0, NULL, 0, N_("Output options:"), 0 }, 78 { "strip-all", 's', NULL, OPTION_HIDDEN, NULL, 0 }, 79 { "strip-debug", 'g', NULL, 0, N_("Remove all debugging symbols"), 0 }, 80 { NULL, 'd', NULL, OPTION_ALIAS, NULL, 0 }, 81 { NULL, 'S', NULL, OPTION_ALIAS, NULL, 0 }, 82 { "preserve-dates", 'p', NULL, 0, 83 N_("Copy modified/access timestamps to the output"), 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 relax some ELF rules for input files. */ 143 static bool permissive; 144 145 146 int 147 main (int argc, char *argv[]) 148 { 149 int remaining; 150 int result = 0; 151 152 /* Make memory leak detection possible. */ 153 mtrace (); 154 155 /* We use no threads here which can interfere with handling a stream. */ 156 __fsetlocking (stdin, FSETLOCKING_BYCALLER); 157 __fsetlocking (stdout, FSETLOCKING_BYCALLER); 158 __fsetlocking (stderr, FSETLOCKING_BYCALLER); 159 160 /* Set locale. */ 161 setlocale (LC_ALL, ""); 162 163 /* Make sure the message catalog can be found. */ 164 bindtextdomain (PACKAGE_TARNAME, LOCALEDIR); 165 166 /* Initialize the message catalog. */ 167 textdomain (PACKAGE_TARNAME); 168 169 /* Parse and process arguments. */ 170 if (argp_parse (&argp, argc, argv, 0, &remaining, NULL) != 0) 171 return EXIT_FAILURE; 172 173 /* Tell the library which version we are expecting. */ 174 elf_version (EV_CURRENT); 175 176 if (remaining == argc) 177 /* The user didn't specify a name so we use a.out. */ 178 result = process_file ("a.out"); 179 else 180 { 181 /* If we have seen the '-o' or '-f' option there must be exactly one 182 input file. */ 183 if ((output_fname != NULL || debug_fname != NULL) 184 && remaining + 1 < argc) 185 error (EXIT_FAILURE, 0, gettext ("\ 186 Only one input file allowed together with '-o' and '-f'")); 187 188 /* Process all the remaining files. */ 189 do 190 result |= process_file (argv[remaining]); 191 while (++remaining < argc); 192 } 193 194 return result; 195 } 196 197 198 /* Print the version information. */ 199 static void 200 print_version (FILE *stream, struct argp_state *state __attribute__ ((unused))) 201 { 202 fprintf (stream, "strip (%s) %s\n", PACKAGE_NAME, PACKAGE_VERSION); 203 fprintf (stream, gettext ("\ 204 Copyright (C) %s Red Hat, Inc.\n\ 205 This is free software; see the source for copying conditions. There is NO\n\ 206 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\ 207 "), "2008"); 208 fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper"); 209 } 210 211 212 /* Handle program arguments. */ 213 static error_t 214 parse_opt (int key, char *arg, struct argp_state *state) 215 { 216 switch (key) 217 { 218 case 'f': 219 if (debug_fname != NULL) 220 { 221 error (0, 0, gettext ("-f option specified twice")); 222 return EINVAL; 223 } 224 debug_fname = arg; 225 break; 226 227 case 'F': 228 if (debug_fname_embed != NULL) 229 { 230 error (0, 0, gettext ("-F option specified twice")); 231 return EINVAL; 232 } 233 debug_fname_embed = arg; 234 break; 235 236 case 'o': 237 if (output_fname != NULL) 238 { 239 error (0, 0, gettext ("-o option specified twice")); 240 return EINVAL; 241 } 242 output_fname = arg; 243 break; 244 245 case 'p': 246 preserve_dates = true; 247 break; 248 249 case OPT_REMOVE_COMMENT: 250 remove_comment = true; 251 break; 252 253 case 'R': 254 if (!strcmp (arg, ".comment")) 255 remove_comment = true; 256 else 257 { 258 argp_error (state, 259 gettext ("-R option supports only .comment section")); 260 return EINVAL; 261 } 262 break; 263 264 case 'g': 265 case 'd': 266 case 'S': 267 remove_debug = true; 268 break; 269 270 case OPT_PERMISSIVE: 271 permissive = true; 272 break; 273 274 case 's': /* Ignored for compatibility. */ 275 break; 276 277 default: 278 return ARGP_ERR_UNKNOWN; 279 } 280 return 0; 281 } 282 283 284 static int 285 process_file (const char *fname) 286 { 287 /* If we have to preserve the modify and access timestamps get them 288 now. We cannot use fstat() after opening the file since the open 289 would change the access time. */ 290 struct stat64 pre_st; 291 struct timeval tv[2]; 292 again: 293 if (preserve_dates) 294 { 295 if (stat64 (fname, &pre_st) != 0) 296 { 297 error (0, errno, gettext ("cannot stat input file '%s'"), fname); 298 return 1; 299 } 300 301 /* If we have to preserve the timestamp, we need it in the 302 format utimes() understands. */ 303 TIMESPEC_TO_TIMEVAL (&tv[0], &pre_st.st_atim); 304 TIMESPEC_TO_TIMEVAL (&tv[1], &pre_st.st_mtim); 305 } 306 307 /* Open the file. */ 308 int fd = open (fname, output_fname == NULL ? O_RDWR : O_RDONLY); 309 if (fd == -1) 310 { 311 error (0, errno, gettext ("while opening '%s'"), fname); 312 return 1; 313 } 314 315 /* We always use fstat() even if we called stat() before. This is 316 done to make sure the information returned by stat() is for the 317 same file. */ 318 struct stat64 st; 319 if (fstat64 (fd, &st) != 0) 320 { 321 error (0, errno, gettext ("cannot stat input file '%s'"), fname); 322 return 1; 323 } 324 /* Paranoid mode on. */ 325 if (preserve_dates 326 && (st.st_ino != pre_st.st_ino || st.st_dev != pre_st.st_dev)) 327 { 328 /* We detected a race. Try again. */ 329 close (fd); 330 goto again; 331 } 332 333 /* Now get the ELF descriptor. */ 334 Elf *elf = elf_begin (fd, output_fname == NULL ? ELF_C_RDWR : ELF_C_READ, 335 NULL); 336 int result; 337 switch (elf_kind (elf)) 338 { 339 case ELF_K_ELF: 340 result = handle_elf (fd, elf, NULL, fname, st.st_mode & ACCESSPERMS, 341 preserve_dates ? tv : NULL); 342 break; 343 344 case ELF_K_AR: 345 /* It is not possible to strip the content of an archive direct 346 the output to a specific file. */ 347 if (unlikely (output_fname != NULL || debug_fname != NULL)) 348 { 349 error (0, 0, gettext ("%s: cannot use -o or -f when stripping archive"), 350 fname); 351 result = 1; 352 } 353 else 354 result = handle_ar (fd, elf, NULL, fname, preserve_dates ? tv : NULL); 355 break; 356 357 default: 358 error (0, 0, gettext ("%s: File format not recognized"), fname); 359 result = 1; 360 break; 361 } 362 363 if (unlikely (elf_end (elf) != 0)) 364 INTERNAL_ERROR (fname); 365 366 close (fd); 367 368 return result; 369 } 370 371 372 /* Maximum size of array allocated on stack. */ 373 #define MAX_STACK_ALLOC (400 * 1024) 374 375 static int 376 handle_elf (int fd, Elf *elf, const char *prefix, const char *fname, 377 mode_t mode, struct timeval tvp[2]) 378 { 379 size_t prefix_len = prefix == NULL ? 0 : strlen (prefix); 380 size_t fname_len = strlen (fname) + 1; 381 char *fullname = alloca (prefix_len + 1 + fname_len); 382 char *cp = fullname; 383 Elf *debugelf = NULL; 384 char *tmp_debug_fname = NULL; 385 int result = 0; 386 size_t shdridx = 0; 387 size_t shstrndx; 388 struct shdr_info 389 { 390 Elf_Scn *scn; 391 GElf_Shdr shdr; 392 Elf_Data *data; 393 Elf_Data *debug_data; 394 const char *name; 395 Elf32_Word idx; /* Index in new file. */ 396 Elf32_Word old_sh_link; /* Original value of shdr.sh_link. */ 397 Elf32_Word symtab_idx; 398 Elf32_Word version_idx; 399 Elf32_Word group_idx; 400 Elf32_Word group_cnt; 401 Elf_Scn *newscn; 402 struct Ebl_Strent *se; 403 Elf32_Word *newsymidx; 404 } *shdr_info = NULL; 405 Elf_Scn *scn; 406 size_t cnt; 407 size_t idx; 408 bool changes; 409 GElf_Ehdr newehdr_mem; 410 GElf_Ehdr *newehdr; 411 GElf_Ehdr debugehdr_mem; 412 GElf_Ehdr *debugehdr; 413 struct Ebl_Strtab *shst = NULL; 414 Elf_Data debuglink_crc_data; 415 bool any_symtab_changes = false; 416 Elf_Data *shstrtab_data = NULL; 417 418 /* Create the full name of the file. */ 419 if (prefix != NULL) 420 { 421 cp = mempcpy (cp, prefix, prefix_len); 422 *cp++ = ':'; 423 } 424 memcpy (cp, fname, fname_len); 425 426 /* If we are not replacing the input file open a new file here. */ 427 if (output_fname != NULL) 428 { 429 fd = open (output_fname, O_RDWR | O_CREAT, mode); 430 if (unlikely (fd == -1)) 431 { 432 error (0, errno, gettext ("cannot open '%s'"), output_fname); 433 return 1; 434 } 435 } 436 437 int debug_fd = -1; 438 439 /* Get the EBL handling. The -g option is currently the only reason 440 we need EBL so dont open the backend unless necessary. */ 441 Ebl *ebl = NULL; 442 if (remove_debug) 443 { 444 ebl = ebl_openbackend (elf); 445 if (ebl == NULL) 446 { 447 error (0, errno, gettext ("cannot open EBL backend")); 448 result = 1; 449 goto fail; 450 } 451 } 452 453 /* Open the additional file the debug information will be stored in. */ 454 if (debug_fname != NULL) 455 { 456 /* Create a temporary file name. We do not want to overwrite 457 the debug file if the file would not contain any 458 information. */ 459 size_t debug_fname_len = strlen (debug_fname); 460 tmp_debug_fname = (char *) alloca (debug_fname_len + sizeof (".XXXXXX")); 461 strcpy (mempcpy (tmp_debug_fname, debug_fname, debug_fname_len), 462 ".XXXXXX"); 463 464 debug_fd = mkstemp (tmp_debug_fname); 465 if (unlikely (debug_fd == -1)) 466 { 467 error (0, errno, gettext ("cannot open '%s'"), debug_fname); 468 result = 1; 469 goto fail; 470 } 471 } 472 473 /* Get the information from the old file. */ 474 GElf_Ehdr ehdr_mem; 475 GElf_Ehdr *ehdr = gelf_getehdr (elf, &ehdr_mem); 476 if (ehdr == NULL) 477 INTERNAL_ERROR (fname); 478 479 /* Get the section header string table index. */ 480 if (unlikely (elf_getshstrndx (elf, &shstrndx) < 0)) 481 error (EXIT_FAILURE, 0, 482 gettext ("cannot get section header string table index")); 483 484 /* We now create a new ELF descriptor for the same file. We 485 construct it almost exactly in the same way with some information 486 dropped. */ 487 Elf *newelf; 488 if (output_fname != NULL) 489 newelf = elf_begin (fd, ELF_C_WRITE_MMAP, NULL); 490 else 491 newelf = elf_clone (elf, ELF_C_EMPTY); 492 493 if (unlikely (gelf_newehdr (newelf, gelf_getclass (elf)) == 0) 494 || (ehdr->e_type != ET_REL 495 && unlikely (gelf_newphdr (newelf, ehdr->e_phnum) == 0))) 496 { 497 error (0, 0, gettext ("cannot create new file '%s': %s"), 498 output_fname, elf_errmsg (-1)); 499 goto fail; 500 } 501 502 /* Copy over the old program header if needed. */ 503 if (ehdr->e_type != ET_REL) 504 for (cnt = 0; cnt < ehdr->e_phnum; ++cnt) 505 { 506 GElf_Phdr phdr_mem; 507 GElf_Phdr *phdr = gelf_getphdr (elf, cnt, &phdr_mem); 508 if (phdr == NULL 509 || unlikely (gelf_update_phdr (newelf, cnt, phdr) == 0)) 510 INTERNAL_ERROR (fname); 511 } 512 513 if (debug_fname != NULL) 514 { 515 /* Also create an ELF descriptor for the debug file */ 516 debugelf = elf_begin (debug_fd, ELF_C_WRITE_MMAP, NULL); 517 if (unlikely (gelf_newehdr (debugelf, gelf_getclass (elf)) == 0) 518 || (ehdr->e_type != ET_REL 519 && unlikely (gelf_newphdr (debugelf, ehdr->e_phnum) == 0))) 520 { 521 error (0, 0, gettext ("cannot create new file '%s': %s"), 522 debug_fname, elf_errmsg (-1)); 523 goto fail_close; 524 } 525 526 /* Copy over the old program header if needed. */ 527 if (ehdr->e_type != ET_REL) 528 for (cnt = 0; cnt < ehdr->e_phnum; ++cnt) 529 { 530 GElf_Phdr phdr_mem; 531 GElf_Phdr *phdr = gelf_getphdr (elf, cnt, &phdr_mem); 532 if (phdr == NULL 533 || unlikely (gelf_update_phdr (debugelf, cnt, phdr) == 0)) 534 INTERNAL_ERROR (fname); 535 } 536 } 537 538 /* Number of sections. */ 539 size_t shnum; 540 if (unlikely (elf_getshnum (elf, &shnum) < 0)) 541 { 542 error (0, 0, gettext ("cannot determine number of sections: %s"), 543 elf_errmsg (-1)); 544 goto fail_close; 545 } 546 547 /* Storage for section information. We leave room for two more 548 entries since we unconditionally create a section header string 549 table. Maybe some weird tool created an ELF file without one. 550 The other one is used for the debug link section. */ 551 if ((shnum + 2) * sizeof (struct shdr_info) > MAX_STACK_ALLOC) 552 shdr_info = (struct shdr_info *) xcalloc (shnum + 2, 553 sizeof (struct shdr_info)); 554 else 555 { 556 shdr_info = (struct shdr_info *) alloca ((shnum + 2) 557 * sizeof (struct shdr_info)); 558 memset (shdr_info, '\0', (shnum + 2) * sizeof (struct shdr_info)); 559 } 560 561 /* Prepare section information data structure. */ 562 scn = NULL; 563 cnt = 1; 564 while ((scn = elf_nextscn (elf, scn)) != NULL) 565 { 566 /* This should always be true (i.e., there should not be any 567 holes in the numbering). */ 568 assert (elf_ndxscn (scn) == cnt); 569 570 shdr_info[cnt].scn = scn; 571 572 /* Get the header. */ 573 if (gelf_getshdr (scn, &shdr_info[cnt].shdr) == NULL) 574 INTERNAL_ERROR (fname); 575 576 /* Get the name of the section. */ 577 shdr_info[cnt].name = elf_strptr (elf, shstrndx, 578 shdr_info[cnt].shdr.sh_name); 579 if (shdr_info[cnt].name == NULL) 580 { 581 error (0, 0, gettext ("illformed file '%s'"), fname); 582 goto fail_close; 583 } 584 585 /* Mark them as present but not yet investigated. */ 586 shdr_info[cnt].idx = 1; 587 588 /* Remember the shdr.sh_link value. */ 589 shdr_info[cnt].old_sh_link = shdr_info[cnt].shdr.sh_link; 590 591 /* Sections in files other than relocatable object files which 592 are not loaded can be freely moved by us. In relocatable 593 object files everything can be moved. */ 594 if (ehdr->e_type == ET_REL 595 || (shdr_info[cnt].shdr.sh_flags & SHF_ALLOC) == 0) 596 shdr_info[cnt].shdr.sh_offset = 0; 597 598 /* If this is an extended section index table store an 599 appropriate reference. */ 600 if (unlikely (shdr_info[cnt].shdr.sh_type == SHT_SYMTAB_SHNDX)) 601 { 602 assert (shdr_info[shdr_info[cnt].shdr.sh_link].symtab_idx == 0); 603 shdr_info[shdr_info[cnt].shdr.sh_link].symtab_idx = cnt; 604 } 605 else if (unlikely (shdr_info[cnt].shdr.sh_type == SHT_GROUP)) 606 { 607 /* Cross-reference the sections contained in the section 608 group. */ 609 shdr_info[cnt].data = elf_getdata (shdr_info[cnt].scn, NULL); 610 if (shdr_info[cnt].data == NULL) 611 INTERNAL_ERROR (fname); 612 613 /* XXX Fix for unaligned access. */ 614 Elf32_Word *grpref = (Elf32_Word *) shdr_info[cnt].data->d_buf; 615 size_t inner; 616 for (inner = 1; 617 inner < shdr_info[cnt].data->d_size / sizeof (Elf32_Word); 618 ++inner) 619 shdr_info[grpref[inner]].group_idx = cnt; 620 621 if (inner == 1 || (inner == 2 && (grpref[0] & GRP_COMDAT) == 0)) 622 /* If the section group contains only one element and this 623 is n COMDAT section we can drop it right away. */ 624 shdr_info[cnt].idx = 0; 625 else 626 shdr_info[cnt].group_cnt = inner - 1; 627 } 628 else if (unlikely (shdr_info[cnt].shdr.sh_type == SHT_GNU_versym)) 629 { 630 assert (shdr_info[shdr_info[cnt].shdr.sh_link].version_idx == 0); 631 shdr_info[shdr_info[cnt].shdr.sh_link].version_idx = cnt; 632 } 633 634 /* If this section is part of a group make sure it is not 635 discarded right away. */ 636 if ((shdr_info[cnt].shdr.sh_flags & SHF_GROUP) != 0) 637 { 638 assert (shdr_info[cnt].group_idx != 0); 639 640 if (shdr_info[shdr_info[cnt].group_idx].idx == 0) 641 { 642 /* The section group section will be removed. */ 643 shdr_info[cnt].group_idx = 0; 644 shdr_info[cnt].shdr.sh_flags &= ~SHF_GROUP; 645 } 646 } 647 648 /* Increment the counter. */ 649 ++cnt; 650 } 651 652 /* Now determine which sections can go away. The general rule is that 653 all sections which are not used at runtime are stripped out. But 654 there are a few exceptions: 655 656 - special sections named ".comment" and ".note" are kept 657 - OS or architecture specific sections are kept since we might not 658 know how to handle them 659 - if a section is referred to from a section which is not removed 660 in the sh_link or sh_info element it cannot be removed either 661 */ 662 for (cnt = 1; cnt < shnum; ++cnt) 663 /* Check whether the section can be removed. */ 664 if (ebl_section_strip_p (ebl, ehdr, &shdr_info[cnt].shdr, 665 shdr_info[cnt].name, remove_comment, 666 remove_debug)) 667 { 668 /* For now assume this section will be removed. */ 669 shdr_info[cnt].idx = 0; 670 671 idx = shdr_info[cnt].group_idx; 672 while (idx != 0) 673 { 674 /* The section group data is already loaded. */ 675 assert (shdr_info[idx].data != NULL); 676 677 /* If the references section group is a normal section 678 group and has one element remaining, or if it is an 679 empty COMDAT section group it is removed. */ 680 bool is_comdat = (((Elf32_Word *) shdr_info[idx].data->d_buf)[0] 681 & GRP_COMDAT) != 0; 682 683 --shdr_info[idx].group_cnt; 684 if ((!is_comdat && shdr_info[idx].group_cnt == 1) 685 || (is_comdat && shdr_info[idx].group_cnt == 0)) 686 { 687 shdr_info[idx].idx = 0; 688 /* Continue recursively. */ 689 idx = shdr_info[idx].group_idx; 690 } 691 else 692 break; 693 } 694 } 695 696 /* Mark the SHT_NULL section as handled. */ 697 shdr_info[0].idx = 2; 698 699 700 /* Handle exceptions: section groups and cross-references. We might 701 have to repeat this a few times since the resetting of the flag 702 might propagate. */ 703 do 704 { 705 changes = false; 706 707 for (cnt = 1; cnt < shnum; ++cnt) 708 { 709 if (shdr_info[cnt].idx == 0) 710 { 711 /* If a relocation section is marked as being removed make 712 sure the section it is relocating is removed, too. */ 713 if ((shdr_info[cnt].shdr.sh_type == SHT_REL 714 || shdr_info[cnt].shdr.sh_type == SHT_RELA) 715 && shdr_info[shdr_info[cnt].shdr.sh_info].idx != 0) 716 shdr_info[cnt].idx = 1; 717 } 718 719 if (shdr_info[cnt].idx == 1) 720 { 721 /* The content of symbol tables we don't remove must not 722 reference any section which we do remove. Otherwise 723 we cannot remove the section. */ 724 if (debug_fname != NULL 725 && shdr_info[cnt].debug_data == NULL 726 && (shdr_info[cnt].shdr.sh_type == SHT_DYNSYM 727 || shdr_info[cnt].shdr.sh_type == SHT_SYMTAB)) 728 { 729 /* Make sure the data is loaded. */ 730 if (shdr_info[cnt].data == NULL) 731 { 732 shdr_info[cnt].data 733 = elf_getdata (shdr_info[cnt].scn, NULL); 734 if (shdr_info[cnt].data == NULL) 735 INTERNAL_ERROR (fname); 736 } 737 Elf_Data *symdata = shdr_info[cnt].data; 738 739 /* If there is an extended section index table load it 740 as well. */ 741 if (shdr_info[cnt].symtab_idx != 0 742 && shdr_info[shdr_info[cnt].symtab_idx].data == NULL) 743 { 744 assert (shdr_info[cnt].shdr.sh_type == SHT_SYMTAB); 745 746 shdr_info[shdr_info[cnt].symtab_idx].data 747 = elf_getdata (shdr_info[shdr_info[cnt].symtab_idx].scn, 748 NULL); 749 if (shdr_info[shdr_info[cnt].symtab_idx].data == NULL) 750 INTERNAL_ERROR (fname); 751 } 752 Elf_Data *xndxdata 753 = shdr_info[shdr_info[cnt].symtab_idx].data; 754 755 /* Go through all symbols and make sure the section they 756 reference is not removed. */ 757 size_t elsize = gelf_fsize (elf, ELF_T_SYM, 1, 758 ehdr->e_version); 759 760 for (size_t inner = 0; 761 inner < shdr_info[cnt].data->d_size / elsize; 762 ++inner) 763 { 764 GElf_Sym sym_mem; 765 Elf32_Word xndx; 766 GElf_Sym *sym = gelf_getsymshndx (symdata, xndxdata, 767 inner, &sym_mem, 768 &xndx); 769 if (sym == NULL) 770 INTERNAL_ERROR (fname); 771 772 size_t scnidx = sym->st_shndx; 773 if (scnidx == SHN_UNDEF || scnidx >= shnum 774 || (scnidx >= SHN_LORESERVE 775 && scnidx <= SHN_HIRESERVE 776 && scnidx != SHN_XINDEX) 777 /* Don't count in the section symbols. */ 778 || GELF_ST_TYPE (sym->st_info) == STT_SECTION) 779 /* This is no section index, leave it alone. */ 780 continue; 781 else if (scnidx == SHN_XINDEX) 782 scnidx = xndx; 783 784 if (shdr_info[scnidx].idx == 0) 785 /* This symbol table has a real symbol in 786 a discarded section. So preserve the 787 original table in the debug file. */ 788 shdr_info[cnt].debug_data = symdata; 789 } 790 } 791 792 /* Cross referencing happens: 793 - for the cases the ELF specification says. That are 794 + SHT_DYNAMIC in sh_link to string table 795 + SHT_HASH in sh_link to symbol table 796 + SHT_REL and SHT_RELA in sh_link to symbol table 797 + SHT_SYMTAB and SHT_DYNSYM in sh_link to string table 798 + SHT_GROUP in sh_link to symbol table 799 + SHT_SYMTAB_SHNDX in sh_link to symbol table 800 Other (OS or architecture-specific) sections might as 801 well use this field so we process it unconditionally. 802 - references inside section groups 803 - specially marked references in sh_info if the SHF_INFO_LINK 804 flag is set 805 */ 806 807 if (shdr_info[shdr_info[cnt].shdr.sh_link].idx == 0) 808 { 809 shdr_info[shdr_info[cnt].shdr.sh_link].idx = 1; 810 changes |= shdr_info[cnt].shdr.sh_link < cnt; 811 } 812 813 /* Handle references through sh_info. */ 814 if (SH_INFO_LINK_P (&shdr_info[cnt].shdr) 815 && shdr_info[shdr_info[cnt].shdr.sh_info].idx == 0) 816 { 817 shdr_info[shdr_info[cnt].shdr.sh_info].idx = 1; 818 changes |= shdr_info[cnt].shdr.sh_info < cnt; 819 } 820 821 /* Mark the section as investigated. */ 822 shdr_info[cnt].idx = 2; 823 } 824 825 if (debug_fname != NULL 826 && (shdr_info[cnt].idx == 0 || shdr_info[cnt].debug_data != NULL)) 827 { 828 /* This section is being preserved in the debug file. 829 Sections it refers to must be preserved there too. 830 831 In this pass we mark sections to be preserved in both 832 files by setting the .debug_data pointer to the original 833 file's .data pointer. Below, we'll copy the section 834 contents. */ 835 836 inline void check_preserved (size_t i) 837 { 838 if (i != 0 && shdr_info[i].idx != 0) 839 { 840 if (shdr_info[i].data == NULL) 841 shdr_info[i].data = elf_getdata (shdr_info[i].scn, NULL); 842 if (shdr_info[i].data == NULL) 843 INTERNAL_ERROR (fname); 844 845 shdr_info[i].debug_data = shdr_info[i].data; 846 changes |= i < cnt; 847 } 848 } 849 850 check_preserved (shdr_info[cnt].shdr.sh_link); 851 if (SH_INFO_LINK_P (&shdr_info[cnt].shdr)) 852 check_preserved (shdr_info[cnt].shdr.sh_info); 853 } 854 } 855 } 856 while (changes); 857 858 /* Copy the removed sections to the debug output file. 859 The ones that are not removed in the stripped file are SHT_NOBITS. */ 860 if (debug_fname != NULL) 861 { 862 for (cnt = 1; cnt < shnum; ++cnt) 863 { 864 scn = elf_newscn (debugelf); 865 if (scn == NULL) 866 error (EXIT_FAILURE, 0, 867 gettext ("while generating output file: %s"), 868 elf_errmsg (-1)); 869 870 bool discard_section = (shdr_info[cnt].idx > 0 871 && shdr_info[cnt].debug_data == NULL 872 && shdr_info[cnt].shdr.sh_type != SHT_NOTE 873 && cnt != ehdr->e_shstrndx); 874 875 /* Set the section header in the new file. */ 876 GElf_Shdr debugshdr = shdr_info[cnt].shdr; 877 if (discard_section) 878 debugshdr.sh_type = SHT_NOBITS; 879 880 if (unlikely (gelf_update_shdr (scn, &debugshdr) == 0)) 881 /* There cannot be any overflows. */ 882 INTERNAL_ERROR (fname); 883 884 /* Get the data from the old file if necessary. */ 885 if (shdr_info[cnt].data == NULL) 886 { 887 shdr_info[cnt].data = elf_getdata (shdr_info[cnt].scn, NULL); 888 if (shdr_info[cnt].data == NULL) 889 INTERNAL_ERROR (fname); 890 } 891 892 /* Set the data. This is done by copying from the old file. */ 893 Elf_Data *debugdata = elf_newdata (scn); 894 if (debugdata == NULL) 895 INTERNAL_ERROR (fname); 896 897 /* Copy the structure. This data may be modified in place 898 before we write out the file. */ 899 *debugdata = *shdr_info[cnt].data; 900 if (discard_section) 901 debugdata->d_buf = NULL; 902 else if (shdr_info[cnt].debug_data != NULL) 903 { 904 /* Copy the original data before it gets modified. */ 905 shdr_info[cnt].debug_data = debugdata; 906 debugdata->d_buf = memcpy (xmalloc (debugdata->d_size), 907 debugdata->d_buf, debugdata->d_size); 908 } 909 } 910 911 /* Finish the ELF header. Fill in the fields not handled by 912 libelf from the old file. */ 913 debugehdr = gelf_getehdr (debugelf, &debugehdr_mem); 914 if (debugehdr == NULL) 915 INTERNAL_ERROR (fname); 916 917 memcpy (debugehdr->e_ident, ehdr->e_ident, EI_NIDENT); 918 debugehdr->e_type = ehdr->e_type; 919 debugehdr->e_machine = ehdr->e_machine; 920 debugehdr->e_version = ehdr->e_version; 921 debugehdr->e_entry = ehdr->e_entry; 922 debugehdr->e_flags = ehdr->e_flags; 923 debugehdr->e_shstrndx = ehdr->e_shstrndx; 924 925 if (unlikely (gelf_update_ehdr (debugelf, debugehdr) == 0)) 926 { 927 error (0, 0, gettext ("%s: error while creating ELF header: %s"), 928 debug_fname, elf_errmsg (-1)); 929 result = 1; 930 goto fail_close; 931 } 932 } 933 934 /* Mark the section header string table as unused, we will create 935 a new one. */ 936 shdr_info[shstrndx].idx = 0; 937 938 /* We need a string table for the section headers. */ 939 shst = ebl_strtabinit (true); 940 if (shst == NULL) 941 error (EXIT_FAILURE, errno, gettext ("while preparing output for '%s'"), 942 output_fname ?: fname); 943 944 /* Assign new section numbers. */ 945 shdr_info[0].idx = 0; 946 for (cnt = idx = 1; cnt < shnum; ++cnt) 947 if (shdr_info[cnt].idx > 0) 948 { 949 shdr_info[cnt].idx = idx++; 950 951 /* Create a new section. */ 952 shdr_info[cnt].newscn = elf_newscn (newelf); 953 if (shdr_info[cnt].newscn == NULL) 954 error (EXIT_FAILURE, 0, gettext ("while generating output file: %s"), 955 elf_errmsg (-1)); 956 957 assert (elf_ndxscn (shdr_info[cnt].newscn) == shdr_info[cnt].idx); 958 959 /* Add this name to the section header string table. */ 960 shdr_info[cnt].se = ebl_strtabadd (shst, shdr_info[cnt].name, 0); 961 } 962 963 /* Test whether we are doing anything at all. */ 964 if (cnt == idx) 965 /* Nope, all removable sections are already gone. */ 966 goto fail_close; 967 968 /* Create the reference to the file with the debug info. */ 969 if (debug_fname != NULL) 970 { 971 /* Add the section header string table section name. */ 972 shdr_info[cnt].se = ebl_strtabadd (shst, ".gnu_debuglink", 15); 973 shdr_info[cnt].idx = idx++; 974 975 /* Create the section header. */ 976 shdr_info[cnt].shdr.sh_type = SHT_PROGBITS; 977 shdr_info[cnt].shdr.sh_flags = 0; 978 shdr_info[cnt].shdr.sh_addr = 0; 979 shdr_info[cnt].shdr.sh_link = SHN_UNDEF; 980 shdr_info[cnt].shdr.sh_info = SHN_UNDEF; 981 shdr_info[cnt].shdr.sh_entsize = 0; 982 shdr_info[cnt].shdr.sh_addralign = 4; 983 /* We set the offset to zero here. Before we write the ELF file the 984 field must have the correct value. This is done in the final 985 loop over all section. Then we have all the information needed. */ 986 shdr_info[cnt].shdr.sh_offset = 0; 987 988 /* Create the section. */ 989 shdr_info[cnt].newscn = elf_newscn (newelf); 990 if (shdr_info[cnt].newscn == NULL) 991 error (EXIT_FAILURE, 0, 992 gettext ("while create section header section: %s"), 993 elf_errmsg (-1)); 994 assert (elf_ndxscn (shdr_info[cnt].newscn) == shdr_info[cnt].idx); 995 996 shdr_info[cnt].data = elf_newdata (shdr_info[cnt].newscn); 997 if (shdr_info[cnt].data == NULL) 998 error (EXIT_FAILURE, 0, gettext ("cannot allocate section data: %s"), 999 elf_errmsg (-1)); 1000 1001 char *debug_basename = basename (debug_fname_embed ?: debug_fname); 1002 off_t crc_offset = strlen (debug_basename) + 1; 1003 /* Align to 4 byte boundary */ 1004 crc_offset = ((crc_offset - 1) & ~3) + 4; 1005 1006 shdr_info[cnt].data->d_align = 4; 1007 shdr_info[cnt].shdr.sh_size = shdr_info[cnt].data->d_size 1008 = crc_offset + 4; 1009 shdr_info[cnt].data->d_buf = xcalloc (1, shdr_info[cnt].data->d_size); 1010 1011 strcpy (shdr_info[cnt].data->d_buf, debug_basename); 1012 1013 /* Cache this Elf_Data describing the CRC32 word in the section. 1014 We'll fill this in when we have written the debug file. */ 1015 debuglink_crc_data = *shdr_info[cnt].data; 1016 debuglink_crc_data.d_buf = ((char *) debuglink_crc_data.d_buf 1017 + crc_offset); 1018 debuglink_crc_data.d_size = 4; 1019 1020 /* One more section done. */ 1021 ++cnt; 1022 } 1023 1024 /* Index of the section header table in the shdr_info array. */ 1025 shdridx = cnt; 1026 1027 /* Add the section header string table section name. */ 1028 shdr_info[cnt].se = ebl_strtabadd (shst, ".shstrtab", 10); 1029 shdr_info[cnt].idx = idx; 1030 1031 /* Create the section header. */ 1032 shdr_info[cnt].shdr.sh_type = SHT_STRTAB; 1033 shdr_info[cnt].shdr.sh_flags = 0; 1034 shdr_info[cnt].shdr.sh_addr = 0; 1035 shdr_info[cnt].shdr.sh_link = SHN_UNDEF; 1036 shdr_info[cnt].shdr.sh_info = SHN_UNDEF; 1037 shdr_info[cnt].shdr.sh_entsize = 0; 1038 /* We set the offset to zero here. Before we write the ELF file the 1039 field must have the correct value. This is done in the final 1040 loop over all section. Then we have all the information needed. */ 1041 shdr_info[cnt].shdr.sh_offset = 0; 1042 shdr_info[cnt].shdr.sh_addralign = 1; 1043 1044 /* Create the section. */ 1045 shdr_info[cnt].newscn = elf_newscn (newelf); 1046 if (shdr_info[cnt].newscn == NULL) 1047 error (EXIT_FAILURE, 0, 1048 gettext ("while create section header section: %s"), 1049 elf_errmsg (-1)); 1050 assert (elf_ndxscn (shdr_info[cnt].newscn) == idx); 1051 1052 /* Finalize the string table and fill in the correct indices in the 1053 section headers. */ 1054 shstrtab_data = elf_newdata (shdr_info[cnt].newscn); 1055 if (shstrtab_data == NULL) 1056 error (EXIT_FAILURE, 0, 1057 gettext ("while create section header string table: %s"), 1058 elf_errmsg (-1)); 1059 ebl_strtabfinalize (shst, shstrtab_data); 1060 1061 /* We have to set the section size. */ 1062 shdr_info[cnt].shdr.sh_size = shstrtab_data->d_size; 1063 1064 /* Update the section information. */ 1065 GElf_Off lastoffset = 0; 1066 for (cnt = 1; cnt <= shdridx; ++cnt) 1067 if (shdr_info[cnt].idx > 0) 1068 { 1069 Elf_Data *newdata; 1070 1071 scn = elf_getscn (newelf, shdr_info[cnt].idx); 1072 assert (scn != NULL); 1073 1074 /* Update the name. */ 1075 shdr_info[cnt].shdr.sh_name = ebl_strtaboffset (shdr_info[cnt].se); 1076 1077 /* Update the section header from the input file. Some fields 1078 might be section indeces which now have to be adjusted. */ 1079 if (shdr_info[cnt].shdr.sh_link != 0) 1080 shdr_info[cnt].shdr.sh_link = 1081 shdr_info[shdr_info[cnt].shdr.sh_link].idx; 1082 1083 if (shdr_info[cnt].shdr.sh_type == SHT_GROUP) 1084 { 1085 assert (shdr_info[cnt].data != NULL); 1086 1087 Elf32_Word *grpref = (Elf32_Word *) shdr_info[cnt].data->d_buf; 1088 for (size_t inner = 0; 1089 inner < shdr_info[cnt].data->d_size / sizeof (Elf32_Word); 1090 ++inner) 1091 grpref[inner] = shdr_info[grpref[inner]].idx; 1092 } 1093 1094 /* Handle the SHT_REL, SHT_RELA, and SHF_INFO_LINK flag. */ 1095 if (SH_INFO_LINK_P (&shdr_info[cnt].shdr)) 1096 shdr_info[cnt].shdr.sh_info = 1097 shdr_info[shdr_info[cnt].shdr.sh_info].idx; 1098 1099 /* Get the data from the old file if necessary. We already 1100 created the data for the section header string table. */ 1101 if (cnt < shnum) 1102 { 1103 if (shdr_info[cnt].data == NULL) 1104 { 1105 shdr_info[cnt].data = elf_getdata (shdr_info[cnt].scn, NULL); 1106 if (shdr_info[cnt].data == NULL) 1107 INTERNAL_ERROR (fname); 1108 } 1109 1110 /* Set the data. This is done by copying from the old file. */ 1111 newdata = elf_newdata (scn); 1112 if (newdata == NULL) 1113 INTERNAL_ERROR (fname); 1114 1115 /* Copy the structure. */ 1116 *newdata = *shdr_info[cnt].data; 1117 1118 /* We know the size. */ 1119 shdr_info[cnt].shdr.sh_size = shdr_info[cnt].data->d_size; 1120 1121 /* We have to adjust symbol tables. The st_shndx member might 1122 have to be updated. */ 1123 if (shdr_info[cnt].shdr.sh_type == SHT_DYNSYM 1124 || shdr_info[cnt].shdr.sh_type == SHT_SYMTAB) 1125 { 1126 Elf_Data *versiondata = NULL; 1127 Elf_Data *shndxdata = NULL; 1128 1129 size_t elsize = gelf_fsize (elf, ELF_T_SYM, 1, 1130 ehdr->e_version); 1131 1132 if (shdr_info[cnt].symtab_idx != 0) 1133 { 1134 assert (shdr_info[cnt].shdr.sh_type == SHT_SYMTAB_SHNDX); 1135 /* This section has extended section information. 1136 We have to modify that information, too. */ 1137 shndxdata = elf_getdata (shdr_info[shdr_info[cnt].symtab_idx].scn, 1138 NULL); 1139 1140 assert ((versiondata->d_size / sizeof (Elf32_Word)) 1141 >= shdr_info[cnt].data->d_size / elsize); 1142 } 1143 1144 if (shdr_info[cnt].version_idx != 0) 1145 { 1146 assert (shdr_info[cnt].shdr.sh_type == SHT_DYNSYM); 1147 /* This section has associated version 1148 information. We have to modify that 1149 information, too. */ 1150 versiondata = elf_getdata (shdr_info[shdr_info[cnt].version_idx].scn, 1151 NULL); 1152 1153 assert ((versiondata->d_size / sizeof (GElf_Versym)) 1154 >= shdr_info[cnt].data->d_size / elsize); 1155 } 1156 1157 shdr_info[cnt].newsymidx 1158 = (Elf32_Word *) xcalloc (shdr_info[cnt].data->d_size 1159 / elsize, sizeof (Elf32_Word)); 1160 1161 bool last_was_local = true; 1162 size_t destidx; 1163 size_t inner; 1164 for (destidx = inner = 1; 1165 inner < shdr_info[cnt].data->d_size / elsize; 1166 ++inner) 1167 { 1168 Elf32_Word sec; 1169 GElf_Sym sym_mem; 1170 Elf32_Word xshndx; 1171 GElf_Sym *sym = gelf_getsymshndx (shdr_info[cnt].data, 1172 shndxdata, inner, 1173 &sym_mem, &xshndx); 1174 if (sym == NULL) 1175 INTERNAL_ERROR (fname); 1176 1177 if (sym->st_shndx == SHN_UNDEF 1178 || (sym->st_shndx >= shnum 1179 && sym->st_shndx != SHN_XINDEX)) 1180 { 1181 /* This is no section index, leave it alone 1182 unless it is moved. */ 1183 if (destidx != inner 1184 && gelf_update_symshndx (shdr_info[cnt].data, 1185 shndxdata, 1186 destidx, sym, 1187 xshndx) == 0) 1188 INTERNAL_ERROR (fname); 1189 1190 shdr_info[cnt].newsymidx[inner] = destidx++; 1191 1192 if (last_was_local 1193 && GELF_ST_BIND (sym->st_info) != STB_LOCAL) 1194 { 1195 last_was_local = false; 1196 shdr_info[cnt].shdr.sh_info = destidx - 1; 1197 } 1198 1199 continue; 1200 } 1201 1202 /* Get the full section index, if necessary from the 1203 XINDEX table. */ 1204 if (sym->st_shndx != SHN_XINDEX) 1205 sec = shdr_info[sym->st_shndx].idx; 1206 else 1207 { 1208 assert (shndxdata != NULL); 1209 1210 sec = shdr_info[xshndx].idx; 1211 } 1212 1213 if (sec != 0) 1214 { 1215 GElf_Section nshndx; 1216 Elf32_Word nxshndx; 1217 1218 if (sec < SHN_LORESERVE) 1219 { 1220 nshndx = sec; 1221 nxshndx = 0; 1222 } 1223 else 1224 { 1225 nshndx = SHN_XINDEX; 1226 nxshndx = sec; 1227 } 1228 1229 assert (sec < SHN_LORESERVE || shndxdata != NULL); 1230 1231 if ((inner != destidx || nshndx != sym->st_shndx 1232 || (shndxdata != NULL && nxshndx != xshndx)) 1233 && (sym->st_shndx = nshndx, 1234 gelf_update_symshndx (shdr_info[cnt].data, 1235 shndxdata, 1236 destidx, sym, 1237 nxshndx) == 0)) 1238 INTERNAL_ERROR (fname); 1239 1240 shdr_info[cnt].newsymidx[inner] = destidx++; 1241 1242 if (last_was_local 1243 && GELF_ST_BIND (sym->st_info) != STB_LOCAL) 1244 { 1245 last_was_local = false; 1246 shdr_info[cnt].shdr.sh_info = destidx - 1; 1247 } 1248 } 1249 else if (debug_fname == NULL 1250 || shdr_info[cnt].debug_data == NULL) 1251 /* This is a section symbol for a section which has 1252 been removed. */ 1253 assert (GELF_ST_TYPE (sym->st_info) == STT_SECTION); 1254 } 1255 1256 if (destidx != inner) 1257 { 1258 /* The size of the symbol table changed. */ 1259 shdr_info[cnt].shdr.sh_size = newdata->d_size 1260 = destidx * elsize; 1261 any_symtab_changes = true; 1262 } 1263 else 1264 { 1265 /* The symbol table didn't really change. */ 1266 free (shdr_info[cnt].newsymidx); 1267 shdr_info[cnt].newsymidx = NULL; 1268 } 1269 } 1270 } 1271 1272 /* If we have to, compute the offset of the section. */ 1273 if (shdr_info[cnt].shdr.sh_offset == 0) 1274 shdr_info[cnt].shdr.sh_offset 1275 = ((lastoffset + shdr_info[cnt].shdr.sh_addralign - 1) 1276 & ~((GElf_Off) (shdr_info[cnt].shdr.sh_addralign - 1))); 1277 1278 /* Set the section header in the new file. */ 1279 if (unlikely (gelf_update_shdr (scn, &shdr_info[cnt].shdr) == 0)) 1280 /* There cannot be any overflows. */ 1281 INTERNAL_ERROR (fname); 1282 1283 /* Remember the last section written so far. */ 1284 GElf_Off filesz = (shdr_info[cnt].shdr.sh_type != SHT_NOBITS 1285 ? shdr_info[cnt].shdr.sh_size : 0); 1286 if (lastoffset < shdr_info[cnt].shdr.sh_offset + filesz) 1287 lastoffset = shdr_info[cnt].shdr.sh_offset + filesz; 1288 } 1289 1290 /* Adjust symbol references if symbol tables changed. */ 1291 if (any_symtab_changes) 1292 /* Find all relocation sections which use this symbol table. */ 1293 for (cnt = 1; cnt <= shdridx; ++cnt) 1294 { 1295 /* Update section headers when the data size has changed. 1296 We also update the SHT_NOBITS section in the debug 1297 file so that the section headers match in sh_size. */ 1298 inline void update_section_size (const Elf_Data *newdata) 1299 { 1300 GElf_Shdr shdr_mem; 1301 GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem); 1302 shdr->sh_size = newdata->d_size; 1303 (void) gelf_update_shdr (scn, shdr); 1304 if (debugelf != NULL) 1305 { 1306 /* libelf will use d_size to set sh_size. */ 1307 Elf_Data *debugdata = elf_getdata (elf_getscn (debugelf, 1308 cnt), NULL); 1309 debugdata->d_size = newdata->d_size; 1310 } 1311 } 1312 1313 if (shdr_info[cnt].idx == 0 && debug_fname == NULL) 1314 /* Ignore sections which are discarded. When we are saving a 1315 relocation section in a separate debug file, we must fix up 1316 the symbol table references. */ 1317 continue; 1318 1319 const Elf32_Word symtabidx = shdr_info[cnt].old_sh_link; 1320 const Elf32_Word *const newsymidx = shdr_info[symtabidx].newsymidx; 1321 switch (shdr_info[cnt].shdr.sh_type) 1322 { 1323 inline bool no_symtab_updates (void) 1324 { 1325 /* If the symbol table hasn't changed, do not do anything. */ 1326 if (shdr_info[symtabidx].newsymidx == NULL) 1327 return true; 1328 1329 /* If the symbol table is not discarded, but additionally 1330 duplicated in the separate debug file and this section 1331 is discarded, don't adjust anything. */ 1332 return (shdr_info[cnt].idx == 0 1333 && shdr_info[symtabidx].debug_data != NULL); 1334 } 1335 1336 case SHT_REL: 1337 case SHT_RELA: 1338 if (no_symtab_updates ()) 1339 break; 1340 1341 Elf_Data *d = elf_getdata (shdr_info[cnt].idx == 0 1342 ? elf_getscn (debugelf, cnt) 1343 : elf_getscn (newelf, 1344 shdr_info[cnt].idx), 1345 NULL); 1346 assert (d != NULL); 1347 size_t nrels = (shdr_info[cnt].shdr.sh_size 1348 / shdr_info[cnt].shdr.sh_entsize); 1349 1350 if (shdr_info[cnt].shdr.sh_type == SHT_REL) 1351 for (size_t relidx = 0; relidx < nrels; ++relidx) 1352 { 1353 GElf_Rel rel_mem; 1354 if (gelf_getrel (d, relidx, &rel_mem) == NULL) 1355 INTERNAL_ERROR (fname); 1356 1357 size_t symidx = GELF_R_SYM (rel_mem.r_info); 1358 if (newsymidx[symidx] != symidx) 1359 { 1360 rel_mem.r_info 1361 = GELF_R_INFO (newsymidx[symidx], 1362 GELF_R_TYPE (rel_mem.r_info)); 1363 1364 if (gelf_update_rel (d, relidx, &rel_mem) == 0) 1365 INTERNAL_ERROR (fname); 1366 } 1367 } 1368 else 1369 for (size_t relidx = 0; relidx < nrels; ++relidx) 1370 { 1371 GElf_Rela rel_mem; 1372 if (gelf_getrela (d, relidx, &rel_mem) == NULL) 1373 INTERNAL_ERROR (fname); 1374 1375 size_t symidx = GELF_R_SYM (rel_mem.r_info); 1376 if (newsymidx[symidx] != symidx) 1377 { 1378 rel_mem.r_info 1379 = GELF_R_INFO (newsymidx[symidx], 1380 GELF_R_TYPE (rel_mem.r_info)); 1381 1382 if (gelf_update_rela (d, relidx, &rel_mem) == 0) 1383 INTERNAL_ERROR (fname); 1384 } 1385 } 1386 break; 1387 1388 case SHT_HASH: 1389 if (no_symtab_updates ()) 1390 break; 1391 1392 /* We have to recompute the hash table. */ 1393 1394 assert (shdr_info[cnt].idx > 0); 1395 1396 /* The hash section in the new file. */ 1397 scn = elf_getscn (newelf, shdr_info[cnt].idx); 1398 1399 /* The symbol table data. */ 1400 Elf_Data *symd = elf_getdata (elf_getscn (newelf, 1401 shdr_info[symtabidx].idx), 1402 NULL); 1403 assert (symd != NULL); 1404 1405 /* The hash table data. */ 1406 Elf_Data *hashd = elf_getdata (scn, NULL); 1407 assert (hashd != NULL); 1408 1409 if (shdr_info[cnt].shdr.sh_entsize == sizeof (Elf32_Word)) 1410 { 1411 /* Sane arches first. */ 1412 Elf32_Word *bucket = (Elf32_Word *) hashd->d_buf; 1413 1414 size_t strshndx = shdr_info[symtabidx].old_sh_link; 1415 size_t elsize = gelf_fsize (elf, ELF_T_SYM, 1, 1416 ehdr->e_version); 1417 1418 /* Adjust the nchain value. The symbol table size 1419 changed. We keep the same size for the bucket array. */ 1420 bucket[1] = symd->d_size / elsize; 1421 Elf32_Word nbucket = bucket[0]; 1422 bucket += 2; 1423 Elf32_Word *chain = bucket + nbucket; 1424 1425 /* New size of the section. */ 1426 hashd->d_size = ((2 + symd->d_size / elsize + nbucket) 1427 * sizeof (Elf32_Word)); 1428 update_section_size (hashd); 1429 1430 /* Clear the arrays. */ 1431 memset (bucket, '\0', 1432 (symd->d_size / elsize + nbucket) 1433 * sizeof (Elf32_Word)); 1434 1435 for (size_t inner = shdr_info[symtabidx].shdr.sh_info; 1436 inner < symd->d_size / elsize; ++inner) 1437 { 1438 GElf_Sym sym_mem; 1439 GElf_Sym *sym = gelf_getsym (symd, inner, &sym_mem); 1440 assert (sym != NULL); 1441 1442 const char *name = elf_strptr (elf, strshndx, 1443 sym->st_name); 1444 assert (name != NULL); 1445 size_t hidx = elf_hash (name) % nbucket; 1446 1447 if (bucket[hidx] == 0) 1448 bucket[hidx] = inner; 1449 else 1450 { 1451 hidx = bucket[hidx]; 1452 1453 while (chain[hidx] != 0) 1454 hidx = chain[hidx]; 1455 1456 chain[hidx] = inner; 1457 } 1458 } 1459 } 1460 else 1461 { 1462 /* Alpha and S390 64-bit use 64-bit SHT_HASH entries. */ 1463 assert (shdr_info[cnt].shdr.sh_entsize 1464 == sizeof (Elf64_Xword)); 1465 1466 Elf64_Xword *bucket = (Elf64_Xword *) 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 Elf64_Xword nbucket = bucket[0]; 1476 bucket += 2; 1477 Elf64_Xword *chain = bucket + nbucket; 1478 1479 /* New size of the section. */ 1480 hashd->d_size = ((2 + symd->d_size / elsize + nbucket) 1481 * sizeof (Elf64_Xword)); 1482 update_section_size (hashd); 1483 1484 /* Clear the arrays. */ 1485 memset (bucket, '\0', 1486 (symd->d_size / elsize + nbucket) 1487 * sizeof (Elf64_Xword)); 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 break; 1515 1516 case SHT_GNU_versym: 1517 /* If the symbol table changed we have to adjust the entries. */ 1518 if (no_symtab_updates ()) 1519 break; 1520 1521 assert (shdr_info[cnt].idx > 0); 1522 1523 /* The symbol version section in the new file. */ 1524 scn = elf_getscn (newelf, shdr_info[cnt].idx); 1525 1526 /* The symbol table data. */ 1527 symd = elf_getdata (elf_getscn (newelf, shdr_info[symtabidx].idx), 1528 NULL); 1529 assert (symd != NULL); 1530 1531 /* The version symbol data. */ 1532 Elf_Data *verd = elf_getdata (scn, NULL); 1533 assert (verd != NULL); 1534 1535 /* The symbol version array. */ 1536 GElf_Half *verstab = (GElf_Half *) verd->d_buf; 1537 1538 /* Walk through the list and */ 1539 size_t elsize = gelf_fsize (elf, verd->d_type, 1, 1540 ehdr->e_version); 1541 for (size_t inner = 1; inner < verd->d_size / elsize; ++inner) 1542 if (newsymidx[inner] != 0) 1543 /* Overwriting the same array works since the 1544 reordering can only move entries to lower indices 1545 in the array. */ 1546 verstab[newsymidx[inner]] = verstab[inner]; 1547 1548 /* New size of the section. */ 1549 verd->d_size = gelf_fsize (newelf, verd->d_type, 1550 symd->d_size 1551 / gelf_fsize (elf, symd->d_type, 1, 1552 ehdr->e_version), 1553 ehdr->e_version); 1554 update_section_size (verd); 1555 break; 1556 1557 case SHT_GROUP: 1558 if (no_symtab_updates ()) 1559 break; 1560 1561 /* Yes, the symbol table changed. 1562 Update the section header of the section group. */ 1563 scn = elf_getscn (newelf, shdr_info[cnt].idx); 1564 GElf_Shdr shdr_mem; 1565 GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem); 1566 assert (shdr != NULL); 1567 1568 shdr->sh_info = newsymidx[shdr->sh_info]; 1569 1570 (void) gelf_update_shdr (scn, shdr); 1571 break; 1572 } 1573 } 1574 1575 /* Now that we have done all adjustments to the data, 1576 we can actually write out the debug file. */ 1577 if (debug_fname != NULL) 1578 { 1579 uint32_t debug_crc; 1580 Elf_Data debug_crc_data = 1581 { 1582 .d_type = ELF_T_WORD, 1583 .d_buf = &debug_crc, 1584 .d_size = sizeof (debug_crc), 1585 .d_version = EV_CURRENT 1586 }; 1587 1588 /* Finally write the file. */ 1589 if (unlikely (elf_update (debugelf, ELF_C_WRITE) == -1)) 1590 { 1591 error (0, 0, gettext ("while writing '%s': %s"), 1592 debug_fname, elf_errmsg (-1)); 1593 result = 1; 1594 goto fail_close; 1595 } 1596 1597 /* Create the real output file. First rename, then change the 1598 mode. */ 1599 if (rename (tmp_debug_fname, debug_fname) != 0 1600 || fchmod (debug_fd, mode) != 0) 1601 { 1602 error (0, errno, gettext ("while creating '%s'"), debug_fname); 1603 result = 1; 1604 goto fail_close; 1605 } 1606 1607 /* The temporary file does not exist anymore. */ 1608 tmp_debug_fname = NULL; 1609 1610 /* Compute the checksum which we will add to the executable. */ 1611 if (crc32_file (debug_fd, &debug_crc) != 0) 1612 { 1613 error (0, errno, 1614 gettext ("while computing checksum for debug information")); 1615 unlink (debug_fname); 1616 result = 1; 1617 goto fail_close; 1618 } 1619 1620 /* Store it in the debuglink section data. */ 1621 if (unlikely (gelf_xlatetof (newelf, &debuglink_crc_data, 1622 &debug_crc_data, ehdr->e_ident[EI_DATA]) 1623 != &debuglink_crc_data)) 1624 INTERNAL_ERROR (fname); 1625 } 1626 1627 /* Finally finish the ELF header. Fill in the fields not handled by 1628 libelf from the old file. */ 1629 newehdr = gelf_getehdr (newelf, &newehdr_mem); 1630 if (newehdr == NULL) 1631 INTERNAL_ERROR (fname); 1632 1633 memcpy (newehdr->e_ident, ehdr->e_ident, EI_NIDENT); 1634 newehdr->e_type = ehdr->e_type; 1635 newehdr->e_machine = ehdr->e_machine; 1636 newehdr->e_version = ehdr->e_version; 1637 newehdr->e_entry = ehdr->e_entry; 1638 newehdr->e_flags = ehdr->e_flags; 1639 newehdr->e_phoff = ehdr->e_phoff; 1640 /* We need to position the section header table. */ 1641 const size_t offsize = gelf_fsize (elf, ELF_T_OFF, 1, EV_CURRENT); 1642 newehdr->e_shoff = ((shdr_info[shdridx].shdr.sh_offset 1643 + shdr_info[shdridx].shdr.sh_size + offsize - 1) 1644 & ~((GElf_Off) (offsize - 1))); 1645 newehdr->e_shentsize = gelf_fsize (elf, ELF_T_SHDR, 1, EV_CURRENT); 1646 1647 /* The new section header string table index. */ 1648 if (likely (idx < SHN_HIRESERVE) && likely (idx != SHN_XINDEX)) 1649 newehdr->e_shstrndx = idx; 1650 else 1651 { 1652 /* The index does not fit in the ELF header field. */ 1653 shdr_info[0].scn = elf_getscn (elf, 0); 1654 1655 if (gelf_getshdr (shdr_info[0].scn, &shdr_info[0].shdr) == NULL) 1656 INTERNAL_ERROR (fname); 1657 1658 shdr_info[0].shdr.sh_link = idx; 1659 (void) gelf_update_shdr (shdr_info[0].scn, &shdr_info[0].shdr); 1660 1661 newehdr->e_shstrndx = SHN_XINDEX; 1662 } 1663 1664 if (gelf_update_ehdr (newelf, newehdr) == 0) 1665 { 1666 error (0, 0, gettext ("%s: error while creating ELF header: %s"), 1667 fname, elf_errmsg (-1)); 1668 return 1; 1669 } 1670 1671 /* We have everything from the old file. */ 1672 if (elf_cntl (elf, ELF_C_FDDONE) != 0) 1673 { 1674 error (0, 0, gettext ("%s: error while reading the file: %s"), 1675 fname, elf_errmsg (-1)); 1676 return 1; 1677 } 1678 1679 /* The ELF library better follows our layout when this is not a 1680 relocatable object file. */ 1681 elf_flagelf (newelf, ELF_C_SET, 1682 (ehdr->e_type != ET_REL ? ELF_F_LAYOUT : 0) 1683 | (permissive ? ELF_F_PERMISSIVE : 0)); 1684 1685 /* Finally write the file. */ 1686 if (elf_update (newelf, ELF_C_WRITE) == -1) 1687 { 1688 error (0, 0, gettext ("while writing '%s': %s"), 1689 fname, elf_errmsg (-1)); 1690 result = 1; 1691 } 1692 1693 fail_close: 1694 if (shdr_info != NULL) 1695 { 1696 /* For some sections we might have created an table to map symbol 1697 table indices. */ 1698 if (any_symtab_changes) 1699 for (cnt = 1; cnt <= shdridx; ++cnt) 1700 { 1701 free (shdr_info[cnt].newsymidx); 1702 if (shdr_info[cnt].debug_data != NULL) 1703 free (shdr_info[cnt].debug_data->d_buf); 1704 } 1705 1706 /* Free the memory. */ 1707 if ((shnum + 2) * sizeof (struct shdr_info) > MAX_STACK_ALLOC) 1708 free (shdr_info); 1709 } 1710 1711 /* Free other resources. */ 1712 if (shstrtab_data != NULL) 1713 free (shstrtab_data->d_buf); 1714 if (shst != NULL) 1715 ebl_strtabfree (shst); 1716 1717 /* That was it. Close the descriptors. */ 1718 if (elf_end (newelf) != 0) 1719 { 1720 error (0, 0, gettext ("error while finishing '%s': %s"), fname, 1721 elf_errmsg (-1)); 1722 result = 1; 1723 } 1724 1725 if (debugelf != NULL && elf_end (debugelf) != 0) 1726 { 1727 error (0, 0, gettext ("error while finishing '%s': %s"), debug_fname, 1728 elf_errmsg (-1)); 1729 result = 1; 1730 } 1731 1732 fail: 1733 /* Close the EBL backend. */ 1734 if (ebl != NULL) 1735 ebl_closebackend (ebl); 1736 1737 /* Close debug file descriptor, if opened */ 1738 if (debug_fd >= 0) 1739 { 1740 if (tmp_debug_fname != NULL) 1741 unlink (tmp_debug_fname); 1742 close (debug_fd); 1743 } 1744 1745 /* If requested, preserve the timestamp. */ 1746 if (tvp != NULL) 1747 { 1748 if (futimes (fd, tvp) != 0) 1749 { 1750 error (0, errno, gettext ("\ 1751 cannot set access and modification date of '%s'"), 1752 output_fname ?: fname); 1753 result = 1; 1754 } 1755 } 1756 1757 /* Close the file descriptor if we created a new file. */ 1758 if (output_fname != NULL) 1759 close (fd); 1760 1761 return result; 1762 } 1763 1764 1765 static int 1766 handle_ar (int fd, Elf *elf, const char *prefix, const char *fname, 1767 struct timeval tvp[2]) 1768 { 1769 size_t prefix_len = prefix == NULL ? 0 : strlen (prefix); 1770 size_t fname_len = strlen (fname) + 1; 1771 char new_prefix[prefix_len + 1 + fname_len]; 1772 char *cp = new_prefix; 1773 1774 /* Create the full name of the file. */ 1775 if (prefix != NULL) 1776 { 1777 cp = mempcpy (cp, prefix, prefix_len); 1778 *cp++ = ':'; 1779 } 1780 memcpy (cp, fname, fname_len); 1781 1782 1783 /* Process all the files contained in the archive. */ 1784 Elf *subelf; 1785 Elf_Cmd cmd = ELF_C_RDWR; 1786 int result = 0; 1787 while ((subelf = elf_begin (fd, cmd, elf)) != NULL) 1788 { 1789 /* The the header for this element. */ 1790 Elf_Arhdr *arhdr = elf_getarhdr (subelf); 1791 1792 if (elf_kind (subelf) == ELF_K_ELF) 1793 result |= handle_elf (fd, subelf, new_prefix, arhdr->ar_name, 0, NULL); 1794 else if (elf_kind (subelf) == ELF_K_AR) 1795 result |= handle_ar (fd, subelf, new_prefix, arhdr->ar_name, NULL); 1796 1797 /* Get next archive element. */ 1798 cmd = elf_next (subelf); 1799 if (unlikely (elf_end (subelf) != 0)) 1800 INTERNAL_ERROR (fname); 1801 } 1802 1803 if (tvp != NULL) 1804 { 1805 if (unlikely (futimes (fd, tvp) != 0)) 1806 { 1807 error (0, errno, gettext ("\ 1808 cannot set access and modification date of '%s'"), fname); 1809 result = 1; 1810 } 1811 } 1812 1813 if (unlikely (close (fd) != 0)) 1814 error (EXIT_FAILURE, errno, gettext ("while closing '%s'"), fname); 1815 1816 return result; 1817 } 1818 1819 1820 #include "debugpred.h" 1821
